feat(cli): doc/kb resource expansion — upload flags + list filters + view fields

Closes deep-tuning gaps in v0.4-shipped doc / kb / session commands.
Each command had multiple SDK fields the CLI silently hardcoded or
omitted; this commit threads them through.

doc upload:
- --enable-multimodel (tri-state via NoOptDefVal): toggle multimodal
  extraction (PDF/DOCX image-to-text) per upload. Empty explicit
  value (e.g. --enable-multimodel="" from uninterpolated shell var)
  rejected as input.invalid_argument rather than silently coerced.
- --metadata key=value (repeatable): attach arbitrary metadata
- --channel <name> (default api, override for browser / wechat ingests)
- URL mode gains --title / --file-type / --tag-id; URL-only flags
  rejected with input.invalid_argument when used without --from-url

doc list filter flags:
- --keyword (server-side LIKE — case-sensitive per PG)
- --file-type / --source / --tag-id
- --start-time / --end-time (RFC3339)

search docs switches from client-side substring to server-side Keyword
via ListKnowledgeWithFilter — smaller wire payload, but case-sensitivity
shifts (documented in CHANGELOG + help text + Long).

MCP doc_list schema gains the same 6 filter fields (parity with CLI).

session view --full + --limit: loads chat history via LoadMessages SDK
method.

kb view human KV expanded: type / pinned / temporary / processing
state + count / summary model / created timestamp. All omit-empty.

doc view human KV expanded: title (when distinct from filename) /
description / source / channel / summary_status / enable_status /
tag_id / storage (human bytes) / file_hash (12-char prefix).
This commit is contained in:
nullkey
2026-05-16 02:38:48 +08:00
committed by lyingbug
parent 7bccd72ba3
commit f89d54362d
17 changed files with 1280 additions and 79 deletions
+41 -1
View File
@@ -37,8 +37,20 @@ type ListOptions struct {
// AllPages walks server pages internally, accumulating items until
// total exhausted or --limit hit.
AllPages bool
// Additional server-side filters (each maps 1:1 to a sdk.KnowledgeListFilter
// field). Empty / zero values are omitted from the request.
Keyword string
FileType string
Source string
TagID string
StartTime string // raw RFC3339; parsed into filter.StartTime
EndTime string // raw RFC3339; parsed into filter.EndTime
}
// rfc3339Example is the canonical RFC3339 hint surfaced when --start-time /
// --end-time fail to parse. Picked to match Go's reference time docs.
const rfc3339Example = "2006-01-02T15:04:05Z"
// docListStatusValues mirrors internal/types/knowledge.go ParseStatus*
// constants - these are the values the server accepts on the
// ?parse_status= query. Kept in sync manually since the SDK doesn't
@@ -92,6 +104,12 @@ backend storage order is not guaranteed and varies between deployments.`,
cmd.Flags().IntVarP(&opts.Limit, "limit", "L", 30, "Maximum results to return (0 = no cap, 1..10000 = explicit)")
cmd.Flags().BoolVar(&opts.AllPages, "all-pages", false, "Walk all server pages until exhausted (or --limit hit)")
cmd.Flags().StringVar(&opts.Status, "status", "", "Filter by parse status: pending | processing | completed | failed")
cmd.Flags().StringVar(&opts.Keyword, "keyword", "", "Server-side substring match against title / file_name (case-sensitive)")
cmd.Flags().StringVar(&opts.FileType, "file-type", "", `Filter by file extension (e.g. "pdf", "md")`)
cmd.Flags().StringVar(&opts.Source, "source", "", `Filter by ingestion source (e.g. "api", "web")`)
cmd.Flags().StringVar(&opts.TagID, "tag-id", "", "Filter by tag association")
cmd.Flags().StringVar(&opts.StartTime, "start-time", "", "Include docs with updated_at >= this RFC3339 timestamp (e.g. 2006-01-02T15:04:05Z)")
cmd.Flags().StringVar(&opts.EndTime, "end-time", "", "Include docs with updated_at <= this RFC3339 timestamp (e.g. 2006-01-02T15:04:05Z)")
cmdutil.AddJSONFlags(cmd, docListFields)
return cmd
}
@@ -116,7 +134,29 @@ func runList(ctx context.Context, opts *ListOptions, jopts *cmdutil.JSONOptions,
strings.Join(docListStatusValues, " | "), opts.Status),
}
}
filter := sdk.KnowledgeListFilter{ParseStatus: opts.Status}
filter := sdk.KnowledgeListFilter{
ParseStatus: opts.Status,
Keyword: opts.Keyword,
FileType: opts.FileType,
Source: opts.Source,
TagID: opts.TagID,
}
if opts.StartTime != "" {
t, err := time.Parse(time.RFC3339, opts.StartTime)
if err != nil {
return cmdutil.NewError(cmdutil.CodeInputInvalidArgument,
fmt.Sprintf("--start-time must be RFC3339 (e.g. %s), got %q", rfc3339Example, opts.StartTime))
}
filter.StartTime = t
}
if opts.EndTime != "" {
t, err := time.Parse(time.RFC3339, opts.EndTime)
if err != nil {
return cmdutil.NewError(cmdutil.CodeInputInvalidArgument,
fmt.Sprintf("--end-time must be RFC3339 (e.g. %s), got %q", rfc3339Example, opts.EndTime))
}
filter.EndTime = t
}
// Pagination is always 1-indexed internally. --all-pages walks; the
// non-walking path returns the first page only.
+107
View File
@@ -339,3 +339,110 @@ func TestList_AllPages_WithLimit_StopsAtLimit(t *testing.T) {
// Should have called pages 1..3 (60 items) then capped at 50.
assert.LessOrEqual(t, len(svc.calls), 3, "should not walk past the page that fills --limit")
}
// ----- C11: richer filter flags -----
func TestList_Keyword_PassedToFilter(t *testing.T) {
_, _ = iostreams.SetForTest(t)
svc := &fakeListSvc{}
opts := &ListOptions{PageSize: 20, Keyword: "spec"}
require.NoError(t, runList(context.Background(), opts, nil, svc, "kb_xxx"))
assert.Equal(t, "spec", svc.got.filter.Keyword)
}
func TestList_FileType_PassedToFilter(t *testing.T) {
_, _ = iostreams.SetForTest(t)
svc := &fakeListSvc{}
opts := &ListOptions{PageSize: 20, FileType: "pdf"}
require.NoError(t, runList(context.Background(), opts, nil, svc, "kb_xxx"))
assert.Equal(t, "pdf", svc.got.filter.FileType)
}
func TestList_Source_PassedToFilter(t *testing.T) {
_, _ = iostreams.SetForTest(t)
svc := &fakeListSvc{}
opts := &ListOptions{PageSize: 20, Source: "api"}
require.NoError(t, runList(context.Background(), opts, nil, svc, "kb_xxx"))
assert.Equal(t, "api", svc.got.filter.Source)
}
func TestList_TagID_PassedToFilter(t *testing.T) {
_, _ = iostreams.SetForTest(t)
svc := &fakeListSvc{}
opts := &ListOptions{PageSize: 20, TagID: "tag_42"}
require.NoError(t, runList(context.Background(), opts, nil, svc, "kb_xxx"))
assert.Equal(t, "tag_42", svc.got.filter.TagID)
}
func TestList_StartTime_RFC3339Parses(t *testing.T) {
_, _ = iostreams.SetForTest(t)
svc := &fakeListSvc{}
want := "2026-05-01T00:00:00Z"
opts := &ListOptions{PageSize: 20, StartTime: want}
require.NoError(t, runList(context.Background(), opts, nil, svc, "kb_xxx"))
parsed, err := time.Parse(time.RFC3339, want)
require.NoError(t, err)
assert.True(t, svc.got.filter.StartTime.Equal(parsed),
"--start-time must be parsed into filter.StartTime; got %v want %v",
svc.got.filter.StartTime, parsed)
}
func TestList_EndTime_RFC3339Parses(t *testing.T) {
_, _ = iostreams.SetForTest(t)
svc := &fakeListSvc{}
want := "2026-06-30T23:59:59Z"
opts := &ListOptions{PageSize: 20, EndTime: want}
require.NoError(t, runList(context.Background(), opts, nil, svc, "kb_xxx"))
parsed, err := time.Parse(time.RFC3339, want)
require.NoError(t, err)
assert.True(t, svc.got.filter.EndTime.Equal(parsed))
}
func TestList_StartTime_InvalidFormat_Rejected(t *testing.T) {
_, _ = iostreams.SetForTest(t)
opts := &ListOptions{PageSize: 20, StartTime: "tomorrow"}
err := runList(context.Background(), opts, nil, &fakeListSvc{}, "kb_xxx")
require.Error(t, err)
var typed *cmdutil.Error
require.ErrorAs(t, err, &typed)
assert.Equal(t, cmdutil.CodeInputInvalidArgument, typed.Code)
assert.Contains(t, typed.Message, "--start-time")
assert.Contains(t, typed.Message, "RFC3339")
}
func TestList_EndTime_InvalidFormat_Rejected(t *testing.T) {
_, _ = iostreams.SetForTest(t)
opts := &ListOptions{PageSize: 20, EndTime: "2026-05-01"} // date-only, not RFC3339
err := runList(context.Background(), opts, nil, &fakeListSvc{}, "kb_xxx")
require.Error(t, err)
var typed *cmdutil.Error
require.ErrorAs(t, err, &typed)
assert.Equal(t, cmdutil.CodeInputInvalidArgument, typed.Code)
assert.Contains(t, typed.Message, "--end-time")
}
// TestList_AllFiltersCombined drives every new filter flag at once to confirm
// they all land on the same filter struct (AND combine on the server).
func TestList_AllFiltersCombined(t *testing.T) {
_, _ = iostreams.SetForTest(t)
svc := &fakeListSvc{}
opts := &ListOptions{
PageSize: 20,
Status: "completed",
Keyword: "spec",
FileType: "pdf",
Source: "api",
TagID: "tag_42",
StartTime: "2026-01-01T00:00:00Z",
EndTime: "2026-12-31T23:59:59Z",
}
require.NoError(t, runList(context.Background(), opts, nil, svc, "kb_xxx"))
f := svc.got.filter
assert.Equal(t, "completed", f.ParseStatus)
assert.Equal(t, "spec", f.Keyword)
assert.Equal(t, "pdf", f.FileType)
assert.Equal(t, "api", f.Source)
assert.Equal(t, "tag_42", f.TagID)
assert.False(t, f.StartTime.IsZero())
assert.False(t, f.EndTime.IsZero())
}
+143 -11
View File
@@ -5,6 +5,7 @@ import (
"errors"
"fmt"
"os"
"strings"
"github.com/spf13/cobra"
@@ -13,9 +14,10 @@ import (
sdk "github.com/Tencent/WeKnora/client"
)
// uploadChannel is the ingestion-channel tag the server records for CLI uploads.
// Distinct from "web" (browser UI), "browser_extension" (one-click capture),
// and "wechat" (mini-program). The server uses this only for analytics.
// uploadChannel is the default ingestion-channel tag the server records for
// CLI uploads. Distinct from "web" (browser UI), "browser_extension"
// (one-click capture), and "wechat" (mini-program). The server uses this only
// for analytics. Users can override via --channel for cross-tool replay.
const uploadChannel = "api"
// docUploadFields enumerates the fields surfaced for `--json` discovery on
@@ -34,6 +36,25 @@ type UploadOptions struct {
Recursive bool // --recursive: positional arg is a directory; walk + upload each match
Glob string // --glob: filename pattern under --recursive (default "*")
FromURL string // --from-url: ingest a remote URL via SDK CreateKnowledgeFromURL
// EnableMultimodel toggles server-side multimodal extraction
// (e.g. images-in-PDF → OCR'd text). nil means "server default" -
// the flag was not set. true/false explicitly override.
EnableMultimodel *bool
// Metadata is the raw --metadata key=value list. Parsed into a map
// at run-time; empty values allowed, duplicate keys last-wins.
Metadata []string
// Channel overrides the ingestion-channel tag recorded server-side.
// Empty ⇒ uploadChannel ("api"). Free-form: server validates.
Channel string
// URL-mode only fields. RunE-side validation rejects these if
// --from-url is not set (positional file path or --recursive).
Title string // --title: display title (URL mode)
FileType string // --file-type: extension hint for extension-less URLs
TagID string // --tag-id: associate the new knowledge entry with a tag
}
// UploadService is the narrow SDK surface this command depends on.
@@ -70,20 +91,47 @@ has a generic name like "report.pdf" but you want to surface it as e.g.
The three input modes (positional file / --recursive directory walk /
--from-url remote ingest) are mutually exclusive - pass exactly one.
Use --recursive --glob to upload a directory tree (see Examples).`,
Use --recursive --glob to upload a directory tree (see Examples).
Server-side ingestion knobs apply to all modes:
--enable-multimodel Toggle multimodal extraction (image-in-PDF → text).
Unset ⇒ server default; pass true or false to override.
--metadata key=value Attach arbitrary key/value metadata. Repeatable.
Empty value allowed; duplicate keys ⇒ last-wins.
Malformed values (no '=', empty key) ⇒
input.invalid_argument.
--channel <name> Override the ingestion-channel tag (default "api").
URL mode (--from-url) additionally accepts --title, --file-type, and --tag-id.
Passing any of those without --from-url is rejected as input.invalid_argument.`,
Example: ` weknora doc upload report.pdf
weknora doc upload notes.md --kb a32a63ff-fb36-4874-bcaa-30f48570a694
weknora doc upload notes.md --kb my-kb
weknora doc upload q3.pdf --name "Q3 Marketing Report.pdf"
weknora doc upload ./docs --recursive --glob '*.pdf'
weknora doc upload report.pdf --enable-multimodel --metadata team=alpha --metadata sprint=Q4
weknora doc upload ./docs --recursive --glob '*.pdf' --metadata team=alpha
weknora doc upload --from-url https://example.com/whitepaper.pdf
weknora doc upload --from-url https://example.com/article.html --name "Q3 Article"`,
weknora doc upload --from-url https://example.com/no-ext --file-type pdf --title "Whitepaper"
weknora doc upload --from-url https://example.com/article.html --name "Q3 Article" --tag-id tag_abc`,
Args: cobra.MaximumNArgs(1),
RunE: func(c *cobra.Command, args []string) error {
jopts, err := cmdutil.CheckJSONFlags(c)
if err != nil {
return err
}
// Translate the tri-state --enable-multimodel flag into the
// *bool the SDK expects. Cobra's BoolVar can't distinguish
// "unset" from "false", so we register a String flag and read
// Changed() + the raw value here.
if c.Flags().Changed("enable-multimodel") {
raw, _ := c.Flags().GetString("enable-multimodel")
v, perr := parseTriBool(raw)
if perr != nil {
return perr
}
opts.EnableMultimodel = &v
}
if err := validateUploadFlags(opts, args); err != nil {
return err
}
@@ -114,13 +162,71 @@ Use --recursive --glob to upload a directory tree (see Examples).`,
cmd.Flags().BoolVar(&opts.Recursive, "recursive", false, "Treat the positional argument as a directory to walk")
cmd.Flags().StringVar(&opts.Glob, "glob", "*", "Filename pattern to filter when --recursive (e.g. '*.pdf')")
cmd.Flags().StringVar(&opts.FromURL, "from-url", "", "Ingest a remote `URL` (HTTP/HTTPS) instead of a local file")
// Tri-state flag: unset ⇒ server default, "true"/"false" override. The
// raw string is decoded into opts.EnableMultimodel in RunE.
cmd.Flags().String("enable-multimodel", "", "Toggle multimodal extraction (true|false); unset ⇒ server default")
cmd.Flags().Lookup("enable-multimodel").NoOptDefVal = "true"
cmd.Flags().StringSliceVar(&opts.Metadata, "metadata", nil, "Attach metadata `key=value` (repeatable; empty value allowed, last-wins on duplicate keys)")
cmd.Flags().StringVar(&opts.Channel, "channel", "", "Ingestion-channel tag recorded server-side (default \"api\")")
cmd.Flags().StringVar(&opts.Title, "title", "", "Display title for the new entry (--from-url only)")
cmd.Flags().StringVar(&opts.FileType, "file-type", "", "File-type hint such as \"pdf\" when the URL has no extension (--from-url only)")
cmd.Flags().StringVar(&opts.TagID, "tag-id", "", "Tag id to associate with the new entry (--from-url only)")
cmdutil.AddJSONFlags(cmd, docUploadFields)
return cmd
}
// parseTriBool parses the raw --enable-multimodel string into a bool. Bare
// --enable-multimodel (no value) is treated as "true" via NoOptDefVal at
// registration time; callers gate on Changed() so an unset flag never gets
// here. An explicit empty string (e.g. --enable-multimodel="" from an
// uninterpolated shell variable) is rejected as input.invalid_argument
// rather than silently coerced.
func parseTriBool(raw string) (bool, error) {
switch strings.ToLower(strings.TrimSpace(raw)) {
case "true", "1", "yes":
return true, nil
case "false", "0", "no":
return false, nil
default:
return false, cmdutil.NewError(cmdutil.CodeInputInvalidArgument,
fmt.Sprintf("--enable-multimodel expects true|false, got %q", raw))
}
}
// parseMetadataKV converts the raw --metadata key=value slice into a map.
// Empty values are allowed. Duplicate keys ⇒ last-wins. Returns nil when
// the slice is empty so callers pass nil through to the SDK unchanged.
func parseMetadataKV(raw []string) (map[string]string, error) {
if len(raw) == 0 {
return nil, nil
}
out := make(map[string]string, len(raw))
for _, kv := range raw {
eq := strings.IndexByte(kv, '=')
if eq <= 0 {
return nil, cmdutil.NewError(cmdutil.CodeInputInvalidArgument,
fmt.Sprintf("--metadata expects key=value (got %q)", kv))
}
out[kv[:eq]] = kv[eq+1:]
}
return out, nil
}
// effectiveChannel returns the channel string to send to the SDK. Empty
// opts.Channel falls back to the default "api" so the wire payload is
// identical to the pre-flag behavior.
func effectiveChannel(opts *UploadOptions) string {
if opts.Channel != "" {
return opts.Channel
}
return uploadChannel
}
// validateUploadFlags enforces mutual exclusion between the three input
// modes (positional file path / --recursive directory walk / --from-url
// remote ingest) and validates the URL when --from-url is set.
// remote ingest) and validates the URL when --from-url is set. It also
// rejects the URL-mode-only flags (--title, --file-type, --tag-id) when
// --from-url isn't set so misuse fails fast with a typed code.
func validateUploadFlags(opts *UploadOptions, args []string) error {
hasPath := len(args) == 1
hasURL := opts.FromURL != ""
@@ -139,17 +245,39 @@ func validateUploadFlags(opts *UploadOptions, args []string) error {
return cmdutil.NewError(cmdutil.CodeInputInvalidArgument,
"a file path is required (or pass --from-url)")
}
// --title / --file-type / --tag-id are URL-mode only. Reject silently
// ignoring them in file mode to avoid the "set X, server did nothing"
// surprise.
if opts.Title != "" {
return cmdutil.NewError(cmdutil.CodeInputInvalidArgument,
"--title is only valid with --from-url")
}
if opts.FileType != "" {
return cmdutil.NewError(cmdutil.CodeInputInvalidArgument,
"--file-type is only valid with --from-url")
}
if opts.TagID != "" {
return cmdutil.NewError(cmdutil.CodeInputInvalidArgument,
"--tag-id is only valid with --from-url")
}
return nil
}
// runUploadFromURL ingests a remote URL via SDK CreateKnowledgeFromURL.
// `--name` becomes the FileName hint so the server's "known file extension"
// detection upgrades crawl-mode to file-download-mode when appropriate.
// Server-side knobs (--enable-multimodel, --metadata via Title/TagID/FileType)
// propagate when set; the SDK request struct omits empty fields via
// `json:",omitempty"` tags so wire payload stays minimal.
func runUploadFromURL(ctx context.Context, opts *UploadOptions, jopts *cmdutil.JSONOptions, svc UploadService, kbID string) error {
req := sdk.CreateKnowledgeFromURLRequest{
URL: opts.FromURL,
FileName: opts.Name,
Channel: uploadChannel,
URL: opts.FromURL,
FileName: opts.Name,
FileType: opts.FileType,
EnableMultimodel: opts.EnableMultimodel,
Title: opts.Title,
TagID: opts.TagID,
Channel: effectiveChannel(opts),
}
k, err := svc.CreateKnowledgeFromURL(ctx, kbID, req)
if err != nil {
@@ -209,7 +337,11 @@ func validateUploadPath(path string) error {
}
func runUpload(ctx context.Context, opts *UploadOptions, jopts *cmdutil.JSONOptions, svc UploadService, kbID, path string) error {
k, err := svc.CreateKnowledgeFromFile(ctx, kbID, path, nil /*metadata*/, nil /*enableMultimodel*/, opts.Name, uploadChannel)
meta, err := parseMetadataKV(opts.Metadata)
if err != nil {
return err
}
k, err := svc.CreateKnowledgeFromFile(ctx, kbID, path, meta, opts.EnableMultimodel, opts.Name, effectiveChannel(opts))
if err != nil {
return cmdutil.WrapHTTP(err, "upload %s", path)
}
+30 -1
View File
@@ -32,6 +32,34 @@ func runUploadRecursive(ctx context.Context, opts *UploadOptions, jopts *cmdutil
Hint: "drop --name or upload files one at a time",
}
}
// URL-mode-only flags are not meaningful for a directory walk; reject
// them so misuse fails fast (mirrors the file-mode path's check in
// validateUploadFlags - that path runs before --recursive dispatches).
if opts.Title != "" {
return &cmdutil.Error{
Code: cmdutil.CodeInputInvalidArgument,
Message: "--title is only valid with --from-url",
}
}
if opts.FileType != "" {
return &cmdutil.Error{
Code: cmdutil.CodeInputInvalidArgument,
Message: "--file-type is only valid with --from-url",
}
}
if opts.TagID != "" {
return &cmdutil.Error{
Code: cmdutil.CodeInputInvalidArgument,
Message: "--tag-id is only valid with --from-url",
}
}
// Parse --metadata up front so a malformed value aborts before the
// first SDK call - otherwise a typo in `key=value` would only surface
// per-file as repeated identical errors.
meta, err := parseMetadataKV(opts.Metadata)
if err != nil {
return err
}
info, err := os.Stat(dir)
if err != nil {
if os.IsNotExist(err) {
@@ -70,8 +98,9 @@ func runUploadRecursive(ctx context.Context, opts *UploadOptions, jopts *cmdutil
var uploaded, failed []uploadOutcome
var firstFailCode cmdutil.ErrorCode
channel := effectiveChannel(opts)
for _, p := range matches {
k, err := svc.CreateKnowledgeFromFile(ctx, kbID, p, nil, nil, "", uploadChannel)
k, err := svc.CreateKnowledgeFromFile(ctx, kbID, p, meta, opts.EnableMultimodel, "", channel)
if err != nil {
code := cmdutil.ClassifyHTTPError(err)
if firstFailCode == "" {
+74 -3
View File
@@ -25,16 +25,25 @@ type scriptedUploadSvc struct {
err error
}
called []string
// Captures from the most-recent call (every recursive iteration writes
// these; tests that want all-rows can extend to slices later).
lastMetadata map[string]string
lastEnableMultimodel *bool
lastChannel string
}
func (s *scriptedUploadSvc) CreateKnowledgeFromFile(
_ context.Context,
_, filePath string,
_ map[string]string,
_ *bool,
_, _ string,
metadata map[string]string,
enableMultimodel *bool,
_, channel string,
) (*sdk.Knowledge, error) {
s.called = append(s.called, filepath.Base(filePath))
s.lastMetadata = metadata
s.lastEnableMultimodel = enableMultimodel
s.lastChannel = channel
r, ok := s.results[filepath.Base(filePath)]
if !ok {
return &sdk.Knowledge{ID: "doc_" + filepath.Base(filePath), FileName: filepath.Base(filePath)}, nil
@@ -157,6 +166,68 @@ func TestUploadRecursive_RejectsNameFlag(t *testing.T) {
assert.Contains(t, typed.Message, "--name")
}
func TestUploadRecursive_PropagatesMultimodelAndMetadata(t *testing.T) {
_, _ = iostreams.SetForTest(t)
dir := t.TempDir()
mkTree(t, dir, "a.pdf")
svc := &scriptedUploadSvc{}
mm := true
opts := &UploadOptions{
Recursive: true,
Glob: "*",
EnableMultimodel: &mm,
Metadata: []string{"team=alpha"},
Channel: "browser_extension",
}
require.NoError(t, runUploadRecursive(context.Background(), opts, nil, svc, "kb_xxx", dir))
require.NotNil(t, svc.lastEnableMultimodel)
assert.True(t, *svc.lastEnableMultimodel)
assert.Equal(t, map[string]string{"team": "alpha"}, svc.lastMetadata)
assert.Equal(t, "browser_extension", svc.lastChannel)
}
func TestUploadRecursive_MetadataInvalid_NoCalls(t *testing.T) {
_, _ = iostreams.SetForTest(t)
dir := t.TempDir()
mkTree(t, dir, "a.pdf")
svc := &scriptedUploadSvc{}
opts := &UploadOptions{Recursive: true, Glob: "*", Metadata: []string{"badformat"}}
err := runUploadRecursive(context.Background(), opts, nil, svc, "kb_xxx", dir)
require.Error(t, err)
var typed *cmdutil.Error
require.ErrorAs(t, err, &typed)
assert.Equal(t, cmdutil.CodeInputInvalidArgument, typed.Code)
assert.Empty(t, svc.called, "must fail before any per-file call")
}
func TestUploadRecursive_RejectsURLOnlyFlags(t *testing.T) {
_, _ = iostreams.SetForTest(t)
dir := t.TempDir()
mkTree(t, dir, "a.pdf")
for _, tc := range []struct {
name string
opts *UploadOptions
want string
}{
{"title", &UploadOptions{Recursive: true, Glob: "*", Title: "x"}, "--title"},
{"file-type", &UploadOptions{Recursive: true, Glob: "*", FileType: "pdf"}, "--file-type"},
{"tag-id", &UploadOptions{Recursive: true, Glob: "*", TagID: "t"}, "--tag-id"},
} {
t.Run(tc.name, func(t *testing.T) {
svc := &scriptedUploadSvc{}
err := runUploadRecursive(context.Background(), tc.opts, nil, svc, "kb_xxx", dir)
require.Error(t, err)
var typed *cmdutil.Error
require.ErrorAs(t, err, &typed)
assert.Equal(t, cmdutil.CodeInputInvalidArgument, typed.Code)
assert.Contains(t, typed.Message, tc.want)
})
}
}
func TestUploadRecursive_JSON_BareObject(t *testing.T) {
out, _ := iostreams.SetForTest(t)
dir := t.TempDir()
+203
View File
@@ -258,3 +258,206 @@ func TestValidateUploadFlags_NoPathOrURL_Rejected(t *testing.T) {
require.ErrorAs(t, err, &typed)
assert.Equal(t, cmdutil.CodeInputInvalidArgument, typed.Code)
}
// --- C10 expanded flags: multimodel / metadata / channel / URL-mode extras ---
func TestUpload_EnableMultimodel_Set_True(t *testing.T) {
_, _ = iostreams.SetForTest(t)
path := writeTempFile(t, "mm.pdf")
svc := &fakeUploadSvc{resp: &sdk.Knowledge{ID: "doc_mm", FileName: "mm.pdf"}}
mm := true
opts := &UploadOptions{EnableMultimodel: &mm}
require.NoError(t, runUpload(context.Background(), opts, nil, svc, "kb_xxx", path))
require.NotNil(t, svc.got.enableMultimodel, "expected non-nil *bool when flag set")
assert.True(t, *svc.got.enableMultimodel)
}
func TestUpload_EnableMultimodel_Set_False(t *testing.T) {
_, _ = iostreams.SetForTest(t)
path := writeTempFile(t, "mm.pdf")
svc := &fakeUploadSvc{resp: &sdk.Knowledge{ID: "doc_mm", FileName: "mm.pdf"}}
mm := false
opts := &UploadOptions{EnableMultimodel: &mm}
require.NoError(t, runUpload(context.Background(), opts, nil, svc, "kb_xxx", path))
require.NotNil(t, svc.got.enableMultimodel, "explicit false must still surface as non-nil *bool")
assert.False(t, *svc.got.enableMultimodel)
}
// TestParseTriBool pins the empty-string-rejects behavior. Bare
// --enable-multimodel maps to "true" via NoOptDefVal before the flag reaches
// parseTriBool, so an empty value here always indicates an explicit
// --enable-multimodel="" (e.g. uninterpolated $VAR). Silently coercing
// empty to true used to surprise users.
func TestParseTriBool(t *testing.T) {
for _, c := range []struct {
in string
want bool
wantErr bool
}{
{"true", true, false},
{"1", true, false},
{"yes", true, false},
{"false", false, false},
{"0", false, false},
{"no", false, false},
{"", false, true}, // explicit empty rejected
{" ", false, true}, // whitespace rejected
{"maybe", false, true},
} {
t.Run(c.in, func(t *testing.T) {
got, err := parseTriBool(c.in)
if c.wantErr {
require.Error(t, err)
assert.Contains(t, err.Error(), "input.invalid_argument")
return
}
require.NoError(t, err)
assert.Equal(t, c.want, got)
})
}
}
func TestUpload_Metadata_ParseKV(t *testing.T) {
_, _ = iostreams.SetForTest(t)
path := writeTempFile(t, "m.pdf")
svc := &fakeUploadSvc{resp: &sdk.Knowledge{ID: "doc_m", FileName: "m.pdf"}}
opts := &UploadOptions{Metadata: []string{"foo=bar", "baz=qux"}}
require.NoError(t, runUpload(context.Background(), opts, nil, svc, "kb_xxx", path))
assert.Equal(t, map[string]string{"foo": "bar", "baz": "qux"}, svc.got.metadata)
}
func TestUpload_Metadata_EmptyValueAllowed(t *testing.T) {
_, _ = iostreams.SetForTest(t)
path := writeTempFile(t, "m.pdf")
svc := &fakeUploadSvc{resp: &sdk.Knowledge{ID: "doc_m", FileName: "m.pdf"}}
opts := &UploadOptions{Metadata: []string{"foo="}}
require.NoError(t, runUpload(context.Background(), opts, nil, svc, "kb_xxx", path))
assert.Equal(t, map[string]string{"foo": ""}, svc.got.metadata)
}
func TestUpload_Metadata_LastWins(t *testing.T) {
_, _ = iostreams.SetForTest(t)
path := writeTempFile(t, "m.pdf")
svc := &fakeUploadSvc{resp: &sdk.Knowledge{ID: "doc_m", FileName: "m.pdf"}}
opts := &UploadOptions{Metadata: []string{"k=v1", "k=v2"}}
require.NoError(t, runUpload(context.Background(), opts, nil, svc, "kb_xxx", path))
assert.Equal(t, map[string]string{"k": "v2"}, svc.got.metadata)
}
func TestUpload_Metadata_InvalidFormat_NoEquals(t *testing.T) {
_, _ = iostreams.SetForTest(t)
path := writeTempFile(t, "m.pdf")
svc := &fakeUploadSvc{resp: &sdk.Knowledge{ID: "doc_m", FileName: "m.pdf"}}
opts := &UploadOptions{Metadata: []string{"foo"}}
err := runUpload(context.Background(), opts, nil, svc, "kb_xxx", path)
require.Error(t, err)
var typed *cmdutil.Error
require.ErrorAs(t, err, &typed)
assert.Equal(t, cmdutil.CodeInputInvalidArgument, typed.Code)
}
func TestUpload_Metadata_InvalidFormat_EmptyKey(t *testing.T) {
_, _ = iostreams.SetForTest(t)
path := writeTempFile(t, "m.pdf")
svc := &fakeUploadSvc{resp: &sdk.Knowledge{ID: "doc_m", FileName: "m.pdf"}}
opts := &UploadOptions{Metadata: []string{"=bar"}}
err := runUpload(context.Background(), opts, nil, svc, "kb_xxx", path)
require.Error(t, err)
var typed *cmdutil.Error
require.ErrorAs(t, err, &typed)
assert.Equal(t, cmdutil.CodeInputInvalidArgument, typed.Code)
}
func TestUpload_Channel_Override(t *testing.T) {
_, _ = iostreams.SetForTest(t)
path := writeTempFile(t, "c.pdf")
svc := &fakeUploadSvc{resp: &sdk.Knowledge{ID: "doc_c", FileName: "c.pdf"}}
opts := &UploadOptions{Channel: "browser_extension"}
require.NoError(t, runUpload(context.Background(), opts, nil, svc, "kb_xxx", path))
assert.Equal(t, "browser_extension", svc.got.channel)
}
func TestUpload_Channel_DefaultStillAPI(t *testing.T) {
_, _ = iostreams.SetForTest(t)
path := writeTempFile(t, "c.pdf")
svc := &fakeUploadSvc{resp: &sdk.Knowledge{ID: "doc_c", FileName: "c.pdf"}}
// Empty Channel is the runUpload contract for "use default".
opts := &UploadOptions{}
require.NoError(t, runUpload(context.Background(), opts, nil, svc, "kb_xxx", path))
assert.Equal(t, uploadChannel, svc.got.channel)
}
// URL-mode metadata happy paths
func TestUploadFromURL_Title(t *testing.T) {
_, _ = iostreams.SetForTest(t)
svc := &fakeUploadSvc{urlResp: &sdk.Knowledge{ID: "doc_u"}}
opts := &UploadOptions{FromURL: "https://example.com/a.pdf", Title: "My Title"}
require.NoError(t, runUploadFromURL(context.Background(), opts, nil, svc, "kb_xxx"))
assert.Equal(t, "My Title", svc.got.urlReq.Title)
}
func TestUploadFromURL_FileType(t *testing.T) {
_, _ = iostreams.SetForTest(t)
svc := &fakeUploadSvc{urlResp: &sdk.Knowledge{ID: "doc_u"}}
opts := &UploadOptions{FromURL: "https://example.com/no-ext", FileType: "pdf"}
require.NoError(t, runUploadFromURL(context.Background(), opts, nil, svc, "kb_xxx"))
assert.Equal(t, "pdf", svc.got.urlReq.FileType)
}
func TestUploadFromURL_TagID(t *testing.T) {
_, _ = iostreams.SetForTest(t)
svc := &fakeUploadSvc{urlResp: &sdk.Knowledge{ID: "doc_u"}}
opts := &UploadOptions{FromURL: "https://example.com/a.pdf", TagID: "tag_99"}
require.NoError(t, runUploadFromURL(context.Background(), opts, nil, svc, "kb_xxx"))
assert.Equal(t, "tag_99", svc.got.urlReq.TagID)
}
func TestUploadFromURL_EnableMultimodel_Forwarded(t *testing.T) {
_, _ = iostreams.SetForTest(t)
svc := &fakeUploadSvc{urlResp: &sdk.Knowledge{ID: "doc_u"}}
mm := true
opts := &UploadOptions{FromURL: "https://example.com/a.pdf", EnableMultimodel: &mm}
require.NoError(t, runUploadFromURL(context.Background(), opts, nil, svc, "kb_xxx"))
require.NotNil(t, svc.got.urlReq.EnableMultimodel)
assert.True(t, *svc.got.urlReq.EnableMultimodel)
}
func TestUploadFromURL_Channel_Override(t *testing.T) {
_, _ = iostreams.SetForTest(t)
svc := &fakeUploadSvc{urlResp: &sdk.Knowledge{ID: "doc_u"}}
opts := &UploadOptions{FromURL: "https://example.com/a.pdf", Channel: "web"}
require.NoError(t, runUploadFromURL(context.Background(), opts, nil, svc, "kb_xxx"))
assert.Equal(t, "web", svc.got.urlReq.Channel)
}
// URL-only flag misuse: error when used without --from-url.
// validateUploadFlags should reject --title/--file-type/--tag-id paired
// with a positional file path (i.e., no --from-url).
func TestValidateUploadFlags_Title_RequiresFromURL(t *testing.T) {
err := validateUploadFlags(&UploadOptions{Title: "x"}, []string{"/tmp/x.pdf"})
require.Error(t, err)
var typed *cmdutil.Error
require.ErrorAs(t, err, &typed)
assert.Equal(t, cmdutil.CodeInputInvalidArgument, typed.Code)
assert.Contains(t, typed.Message, "--title")
}
func TestValidateUploadFlags_FileType_RequiresFromURL(t *testing.T) {
err := validateUploadFlags(&UploadOptions{FileType: "pdf"}, []string{"/tmp/x.pdf"})
require.Error(t, err)
var typed *cmdutil.Error
require.ErrorAs(t, err, &typed)
assert.Equal(t, cmdutil.CodeInputInvalidArgument, typed.Code)
assert.Contains(t, typed.Message, "--file-type")
}
func TestValidateUploadFlags_TagID_RequiresFromURL(t *testing.T) {
err := validateUploadFlags(&UploadOptions{TagID: "tag_x"}, []string{"/tmp/x.pdf"})
require.Error(t, err)
var typed *cmdutil.Error
require.ErrorAs(t, err, &typed)
assert.Equal(t, cmdutil.CodeInputInvalidArgument, typed.Code)
assert.Contains(t, typed.Message, "--tag-id")
}
+37
View File
@@ -65,21 +65,58 @@ func runView(ctx context.Context, opts *ViewOptions, jopts *cmdutil.JSONOptions,
w := iostreams.IO.Out
fmt.Fprintf(w, "ID: %s\n", doc.ID)
fmt.Fprintf(w, "NAME: %s\n", text.KnowledgeDisplayName(doc.FileName, doc.Title, doc.ID))
// Title is rendered as a separate line only when it adds info over
// NAME (i.e. FileName is set AND differs from Title). When FileName
// is empty, KnowledgeDisplayName already used Title for NAME so a
// duplicate TITLE line would be noise.
if doc.Title != "" && doc.FileName != "" && doc.Title != doc.FileName {
fmt.Fprintf(w, "TITLE: %s\n", doc.Title)
}
if doc.KnowledgeBaseID != "" {
fmt.Fprintf(w, "KB: %s\n", doc.KnowledgeBaseID)
}
if doc.TagID != "" {
fmt.Fprintf(w, "TAG: %s\n", doc.TagID)
}
if doc.Description != "" {
fmt.Fprintf(w, "DESC: %s\n", doc.Description)
}
if doc.FileType != "" {
fmt.Fprintf(w, "TYPE: %s\n", doc.FileType)
}
if doc.Source != "" {
fmt.Fprintf(w, "SOURCE: %s\n", doc.Source)
}
if doc.Channel != "" {
fmt.Fprintf(w, "CHANNEL: %s\n", doc.Channel)
}
if doc.FileSize > 0 {
fmt.Fprintf(w, "SIZE: %s\n", formatSize(doc.FileSize))
}
if doc.StorageSize > 0 {
fmt.Fprintf(w, "STORAGE: %s\n", formatSize(doc.StorageSize))
}
if doc.ParseStatus != "" {
fmt.Fprintf(w, "STATUS: %s\n", doc.ParseStatus)
}
if doc.SummaryStatus != "" {
fmt.Fprintf(w, "SUMMARY: %s\n", doc.SummaryStatus)
}
if doc.EnableStatus != "" {
fmt.Fprintf(w, "ENABLED: %s\n", doc.EnableStatus)
}
if doc.EmbeddingModelID != "" {
fmt.Fprintf(w, "EMBEDDING: %s\n", doc.EmbeddingModelID)
}
if doc.FileHash != "" {
// Git-SHA-style 12-char prefix is enough for de-duplication
// while keeping the line short.
h := doc.FileHash
if len(h) > 12 {
h = h[:12]
}
fmt.Fprintf(w, "HASH: %s\n", h)
}
if !doc.CreatedAt.IsZero() {
fmt.Fprintf(w, "CREATED: %s\n", doc.CreatedAt.Format("2006-01-02 15:04:05"))
}
+140
View File
@@ -122,3 +122,143 @@ func TestView_NotFound_ClassifiedAs404(t *testing.T) {
t.Errorf("expected resource.not_found, got %v", err)
}
}
// --- expanded human render: title/desc/source/channel/etc. ---
func TestView_Title_RendersWhenDifferentFromFileName(t *testing.T) {
out, _ := iostreams.SetForTest(t)
svc := &fakeViewSvc{doc: &sdk.Knowledge{
ID: "doc_t", FileName: "raw.pdf", Title: "Quarterly Plan",
}}
if err := runView(context.Background(), &ViewOptions{}, nil, svc, "doc_t"); err != nil {
t.Fatalf("runView: %v", err)
}
got := out.String()
if !strings.Contains(got, "TITLE:") || !strings.Contains(got, "Quarterly Plan") {
t.Errorf("expected TITLE line:\n%s", got)
}
}
// When Title and FileName are equal, the TITLE line is redundant with NAME
// and should be omitted.
func TestView_Title_OmittedWhenSameAsFileName(t *testing.T) {
out, _ := iostreams.SetForTest(t)
svc := &fakeViewSvc{doc: &sdk.Knowledge{
ID: "doc_t", FileName: "policy.pdf", Title: "policy.pdf",
}}
if err := runView(context.Background(), &ViewOptions{}, nil, svc, "doc_t"); err != nil {
t.Fatalf("runView: %v", err)
}
for _, l := range strings.Split(out.String(), "\n") {
if strings.HasPrefix(l, "TITLE:") {
t.Errorf("TITLE line should be omitted when same as filename: %q", l)
}
}
}
func TestView_Description(t *testing.T) {
out, _ := iostreams.SetForTest(t)
svc := &fakeViewSvc{doc: &sdk.Knowledge{ID: "doc_d", FileName: "x.pdf", Description: "Annual review"}}
if err := runView(context.Background(), &ViewOptions{}, nil, svc, "doc_d"); err != nil {
t.Fatalf("runView: %v", err)
}
if !strings.Contains(out.String(), "Annual review") {
t.Errorf("expected description text:\n%s", out.String())
}
}
func TestView_SourceAndChannel(t *testing.T) {
out, _ := iostreams.SetForTest(t)
svc := &fakeViewSvc{doc: &sdk.Knowledge{
ID: "doc_s", FileName: "x.pdf", Source: "https://example.com/x", Channel: "web",
}}
if err := runView(context.Background(), &ViewOptions{}, nil, svc, "doc_s"); err != nil {
t.Fatalf("runView: %v", err)
}
got := out.String()
for _, want := range []string{"SOURCE:", "https://example.com/x", "CHANNEL:", "web"} {
if !strings.Contains(got, want) {
t.Errorf("missing %q in:\n%s", want, got)
}
}
}
func TestView_SummaryAndEnableStatus(t *testing.T) {
out, _ := iostreams.SetForTest(t)
svc := &fakeViewSvc{doc: &sdk.Knowledge{
ID: "doc_st", FileName: "x.pdf",
SummaryStatus: "completed",
EnableStatus: "disabled",
}}
if err := runView(context.Background(), &ViewOptions{}, nil, svc, "doc_st"); err != nil {
t.Fatalf("runView: %v", err)
}
got := out.String()
for _, want := range []string{"SUMMARY:", "completed", "ENABLED:", "disabled"} {
if !strings.Contains(got, want) {
t.Errorf("missing %q in:\n%s", want, got)
}
}
}
func TestView_TagID(t *testing.T) {
out, _ := iostreams.SetForTest(t)
svc := &fakeViewSvc{doc: &sdk.Knowledge{ID: "doc_t", FileName: "x.pdf", TagID: "tag_abc"}}
if err := runView(context.Background(), &ViewOptions{}, nil, svc, "doc_t"); err != nil {
t.Fatalf("runView: %v", err)
}
got := out.String()
if !strings.Contains(got, "TAG:") || !strings.Contains(got, "tag_abc") {
t.Errorf("expected TAG line:\n%s", got)
}
}
func TestView_StorageSize_Human(t *testing.T) {
out, _ := iostreams.SetForTest(t)
svc := &fakeViewSvc{doc: &sdk.Knowledge{ID: "doc_sz", FileName: "x.pdf", StorageSize: 2 * 1024 * 1024}}
if err := runView(context.Background(), &ViewOptions{}, nil, svc, "doc_sz"); err != nil {
t.Fatalf("runView: %v", err)
}
got := out.String()
if !strings.Contains(got, "STORAGE:") || !strings.Contains(got, "MB") {
t.Errorf("expected STORAGE line with human-readable bytes:\n%s", got)
}
}
func TestView_FileHash_Prefix12(t *testing.T) {
out, _ := iostreams.SetForTest(t)
svc := &fakeViewSvc{doc: &sdk.Knowledge{
ID: "doc_h",
FileName: "x.pdf",
FileHash: "abcdef1234567890fedcba0987654321",
}}
if err := runView(context.Background(), &ViewOptions{}, nil, svc, "doc_h"); err != nil {
t.Fatalf("runView: %v", err)
}
got := out.String()
if !strings.Contains(got, "HASH:") || !strings.Contains(got, "abcdef123456") {
t.Errorf("expected HASH line with 12-char prefix:\n%s", got)
}
if strings.Contains(got, "abcdef1234567890fedcba0987654321") {
t.Errorf("full hash should be truncated, got:\n%s", got)
}
}
func TestView_ErrorMessage_WarnPrefix(t *testing.T) {
out, _ := iostreams.SetForTest(t)
svc := &fakeViewSvc{doc: &sdk.Knowledge{
ID: "doc_e", FileName: "x.pdf", ErrorMessage: "parser failed at offset 4096",
}}
if err := runView(context.Background(), &ViewOptions{}, nil, svc, "doc_e"); err != nil {
t.Fatalf("runView: %v", err)
}
got := out.String()
if !strings.Contains(got, "parser failed at offset 4096") {
t.Errorf("expected error message rendered:\n%s", got)
}
// Either ERROR: or a WARN-prefixed label is acceptable as a "warn"
// signal — assert at least one.
if !strings.Contains(got, "ERROR:") && !strings.Contains(got, "WARN") {
t.Errorf("expected ERROR or WARN prefix on error line:\n%s", got)
}
}