cc8254f862
Two intertwined mainstream-alignment moves bundled because they share
the migration target (every command's --json path):
1. Drop --dry-run entirely. Survey of comparable API-wrapper CLIs
(gh, aws, stripe, lark): none expose --dry-run. The mainstream that
does (kubectl/git/helm/ansible) operates on declarative manifests
or local state where the preview is materially different from the
executed action. WeKnora's CLI just echoed the same parameters
that would have gone on the wire — the preview added no real
signal over `--help` + reading the call site. Removes:
- root --dry-run persistent flag + cmdutil/dryrun.go
- DryRun fields + EmitDryRun calls in 12 write commands
- format.Envelope.DryRun field
- 8 corresponding *_test.go cases
- --dry-run mention from README.md and CHANGELOG.md
- "dry_run":false from 16 golden envelopes
2. Migrate every --json output to bare data:
- New format.WriteJSON / WriteJSONFiltered helpers
(cli/internal/format/bare.go) share filterArrayItems /
filterObjectKeys / writeJQ with the (still-live for now) envelope
filter helpers.
- Read commands (kb/doc/session list+view, search chunks/docs/
sessions/kb, auth list/status, agent list/view, context list,
doctor) emit bare arrays / objects on stdout.
- Write commands (kb create/edit/delete/pin/empty, doc upload/
upload_recursive/delete, session delete, auth login/logout/
refresh/token, link/unlink, context add/use/remove, agent
invoke, chat, api, version) emit bare result objects. Risk
classification dropped — the resource + exit code already
convey the action.
Per-command shape changes:
list / search → []T (was {ok, data:{items:[…]}})
view → T (was {ok, data:T, _meta:…})
create / edit → T
delete / pin / etc. → {id, …action result…}
doctor → {summary, checks}
api → {status, headers, body}
_meta dropped on the read path:
pagination (page/page_size/total/has_more) — agents iterate with
--all-pages or accept --limit (gh CLI parity);
kb_id / context echo — caller already knows what it asked for.
Acceptance contract goldens regenerated for the new bare shape.
Error envelope on stdout (PrintErrorEnvelope) stays live for now —
the envelope-infra deletion lands in the next commit.
189 lines
6.4 KiB
Go
189 lines
6.4 KiB
Go
// Package linkcmd implements `weknora link` — binds the current working
|
|
// directory to a knowledge base by writing .weknora/project.yaml. Always
|
|
// overwrites an existing link silently rather than refusing when one is
|
|
// already present. The cobra Long: text covers the user-facing modes
|
|
// (--kb / TTY / non-TTY).
|
|
package linkcmd
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"time"
|
|
|
|
"github.com/spf13/cobra"
|
|
|
|
"github.com/Tencent/WeKnora/cli/internal/aiclient"
|
|
"github.com/Tencent/WeKnora/cli/internal/cmdutil"
|
|
"github.com/Tencent/WeKnora/cli/internal/format"
|
|
"github.com/Tencent/WeKnora/cli/internal/iostreams"
|
|
"github.com/Tencent/WeKnora/cli/internal/projectlink"
|
|
)
|
|
|
|
// linkFields enumerates the fields surfaced for `--json` discovery on
|
|
// `link`. Tracks the small linkResult struct.
|
|
var linkFields = []string{"context", "kb_id", "kb_name", "project_link_path"}
|
|
|
|
type Options struct {
|
|
KB string // --kb: KB UUID or name; empty triggers interactive prompt on TTY
|
|
}
|
|
|
|
// linkResult is the typed payload emitted under data.
|
|
type linkResult struct {
|
|
Context string `json:"context"`
|
|
KBID string `json:"kb_id"`
|
|
KBName string `json:"kb_name,omitempty"`
|
|
ProjectLinkPath string `json:"project_link_path"`
|
|
}
|
|
|
|
// NewCmd builds the `weknora link` command.
|
|
func NewCmd(f *cmdutil.Factory) *cobra.Command {
|
|
opts := &Options{}
|
|
cmd := &cobra.Command{
|
|
Use: "link",
|
|
Short: "Bind the current directory to a knowledge base",
|
|
Long: `Writes .weknora/project.yaml in the current working directory pointing
|
|
at the supplied knowledge base. Subsequent commands run from this directory
|
|
(or any subdirectory) automatically resolve --kb from the link unless
|
|
overridden by the --kb flag or WEKNORA_KB_ID env var.
|
|
|
|
Pass --kb <id-or-name> for non-interactive use (scripts, CI). Run on a TTY
|
|
without --kb to be prompted from the list of available KBs. Always overwrites
|
|
any existing link — re-run to switch.
|
|
|
|
AI agents: link writes to the user's working directory. Only run it when the
|
|
user explicitly asked to bind this directory; don't run it as a side effect.`,
|
|
Example: ` weknora link --kb a32a63ff-fb36-4874-bcaa-30f48570a694 # explicit UUID
|
|
weknora link --kb engineering # name → id
|
|
weknora link # interactive (TTY)`,
|
|
Args: cobra.NoArgs,
|
|
RunE: func(c *cobra.Command, _ []string) error {
|
|
jopts, err := cmdutil.CheckJSONFlags(c)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return runLink(c.Context(), opts, jopts, f)
|
|
},
|
|
}
|
|
cmd.Flags().StringVar(&opts.KB, "kb", "", "Knowledge base UUID or name; omit on a TTY for interactive prompt")
|
|
cmdutil.AddJSONFlags(cmd, linkFields)
|
|
aiclient.SetAgentHelp(cmd, "Writes .weknora/project.yaml binding cwd to a KB. Pass --kb (id or name) for non-interactive use. Always overwrites.")
|
|
return cmd
|
|
}
|
|
|
|
func runLink(ctx context.Context, opts *Options, jopts *cmdutil.JSONOptions, f *cmdutil.Factory) error {
|
|
cwd, err := os.Getwd()
|
|
if err != nil {
|
|
return cmdutil.Wrapf(cmdutil.CodeLocalFileIO, err, "get cwd")
|
|
}
|
|
linkPath := filepath.Join(cwd, projectlink.DirName, projectlink.FileName)
|
|
|
|
ctxName, err := resolveContext(f)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
kbID, kbName, err := resolveKB(ctx, opts, f)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
link := &projectlink.Project{
|
|
Context: ctxName,
|
|
KBID: kbID,
|
|
CreatedAt: time.Now().UTC(),
|
|
}
|
|
if err := projectlink.Save(linkPath, link); err != nil {
|
|
return cmdutil.Wrapf(cmdutil.CodeLocalFileIO, err, "write project link")
|
|
}
|
|
|
|
r := linkResult{
|
|
Context: ctxName,
|
|
KBID: kbID,
|
|
KBName: kbName,
|
|
ProjectLinkPath: linkPath,
|
|
}
|
|
if jopts.Enabled() {
|
|
return format.WriteJSONFiltered(iostreams.IO.Out, r, jopts.Fields, jopts.JQ)
|
|
}
|
|
if kbName != "" {
|
|
fmt.Fprintf(iostreams.IO.Out, "✓ Linked %s to %s (kb=%s, id=%s)\n", linkPath, ctxName, kbName, kbID)
|
|
} else {
|
|
fmt.Fprintf(iostreams.IO.Out, "✓ Linked %s to %s (kb_id=%s)\n", linkPath, ctxName, kbID)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// resolveContext picks the auth context to record in the link. There is no
|
|
// per-invocation override flag on `weknora link` itself — to record under a
|
|
// different context, use the global persistent flag (`weknora --context
|
|
// staging link --kb my-kb`); the active context at link time is what gets
|
|
// written.
|
|
func resolveContext(f *cmdutil.Factory) (string, error) {
|
|
cfg, err := f.Config()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if cfg.CurrentContext == "" {
|
|
return "", cmdutil.NewError(cmdutil.CodeAuthUnauthenticated, "no active context; run `weknora auth login` first")
|
|
}
|
|
return cfg.CurrentContext, nil
|
|
}
|
|
|
|
// resolveKB resolves --kb to (kbID, kbName). Name is empty when the user
|
|
// passed an id directly. Falls through to an interactive prompt on a TTY
|
|
// when --kb is empty; errors on non-TTY.
|
|
func resolveKB(ctx context.Context, opts *Options, f *cmdutil.Factory) (string, string, error) {
|
|
if opts.KB != "" {
|
|
if cmdutil.IsKBID(opts.KB) {
|
|
return opts.KB, "", nil
|
|
}
|
|
cli, err := f.Client()
|
|
if err != nil {
|
|
return "", "", err
|
|
}
|
|
id, err := cmdutil.ResolveKBNameToID(ctx, cli, opts.KB)
|
|
if err != nil {
|
|
return "", "", err
|
|
}
|
|
return id, opts.KB, nil
|
|
}
|
|
if !iostreams.IO.IsStdoutTTY() {
|
|
return "", "", cmdutil.NewError(cmdutil.CodeKBIDRequired, "--kb is required (no TTY for interactive prompt)")
|
|
}
|
|
cli, err := f.Client()
|
|
if err != nil {
|
|
return "", "", err
|
|
}
|
|
return promptForKB(ctx, cli, f)
|
|
}
|
|
|
|
// promptForKB lists available knowledge bases on stderr, then asks the user
|
|
// for an id or name. Resolved against the listed set so a typed name is
|
|
// converted to the canonical id.
|
|
func promptForKB(ctx context.Context, svc cmdutil.KBLister, f *cmdutil.Factory) (string, string, error) {
|
|
kbs, err := svc.ListKnowledgeBases(ctx)
|
|
if err != nil {
|
|
return "", "", cmdutil.WrapHTTP(err, "list knowledge bases")
|
|
}
|
|
if len(kbs) == 0 {
|
|
return "", "", cmdutil.NewError(cmdutil.CodeKBNotFound, "no knowledge bases visible to active context; create one first")
|
|
}
|
|
fmt.Fprintln(iostreams.IO.Err, "Available knowledge bases:")
|
|
for _, kb := range kbs {
|
|
fmt.Fprintf(iostreams.IO.Err, " %s %s\n", kb.ID, kb.Name)
|
|
}
|
|
p := f.Prompter()
|
|
answer, err := p.Input("Knowledge base id or name", "")
|
|
if err != nil {
|
|
return "", "", cmdutil.Wrapf(cmdutil.CodeInputMissingFlag, err, "kb prompt")
|
|
}
|
|
for _, kb := range kbs {
|
|
if kb.ID == answer || kb.Name == answer {
|
|
return kb.ID, kb.Name, nil
|
|
}
|
|
}
|
|
return "", "", cmdutil.NewError(cmdutil.CodeKBNotFound, fmt.Sprintf("knowledge base not found: %s", answer))
|
|
}
|