@khanglvm/outline-cli 0.1.2 → 0.1.4

package/test/config-store.unit.test.js

@@ -2,6 +2,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import {
   buildProfile,
+  getProfile,
   normalizeBaseUrlWithHints,
   suggestProfileMetadata,
   suggestProfiles,
@@ -70,6 +71,37 @@ test("suggestProfiles ranks profiles by keywords/description/host signals", () =
   assert.ok(Array.isArray(result.matches[0].matchedOn));
 });
 
+test("getProfile can auto-select a strong read-only match when query context is provided", () => {
+  const config = {
+    version: 1,
+    profiles: {
+      engineering: {
+        name: "Engineering",
+        baseUrl: "https://wiki.example.com",
+        description: "Runbooks and incident policy",
+        keywords: ["incident", "runbook", "sre"],
+        auth: { type: "apiKey", apiKey: "ol_api_eng" },
+      },
+      marketing: {
+        name: "Acme Handbook",
+        baseUrl: "https://handbook.acme.example",
+        description: "Marketing campaign and event tracking handbook",
+        keywords: ["tracking", "campaign", "analytics"],
+        auth: { type: "apiKey", apiKey: "ol_api_marketing" },
+      },
+    },
+  };
+
+  const selected = getProfile(config, undefined, {
+    query: "documents search incident runbook sre",
+    allowAutoSelect: true,
+  });
+
+  assert.equal(selected.id, "engineering");
+  assert.equal(selected.selection?.autoSelected, true);
+  assert.equal(selected.selection?.query, "documents search incident runbook sre");
+});
+
 test("suggestProfileMetadata can generate and enrich metadata from hints", () => {
   const next = suggestProfileMetadata({
     id: "acme-handbook",

package/test/hardening.unit.test.js

@@ -24,6 +24,26 @@ test("validateToolArgs rejects unknown args by default", () => {
   );
 });
 
+test("validateToolArgs exposes accepted args and closest suggestions", () => {
+  assert.throws(
+    () => validateToolArgs("auth.info", { vew: "summary", unexpected: true }),
+    (err) => {
+      assert.ok(err instanceof CliError);
+      assert.equal(err.details?.code, "ARG_VALIDATION_FAILED");
+      assert.deepEqual(err.details?.requiredArgs, []);
+      assert.ok(Array.isArray(err.details?.acceptedArgs));
+      assert.ok(err.details.acceptedArgs.includes("view"));
+      assert.ok(err.details.acceptedArgs.includes("compact"));
+      assert.deepEqual(err.details?.unknownArgs, ["vew", "unexpected"]);
+      const typoIssue = err.details?.issues?.find((issue) => issue.path === "args.vew");
+      assert.deepEqual(typoIssue?.suggestions, ["view"]);
+      assert.equal(err.details?.suggestedArgs, undefined);
+      assert.match(err.details?.validationHint || "", /Accepted args:/);
+      return true;
+    }
+  );
+});
+
 test("validateToolArgs supports allowUnknown opt-out", () => {
   const toolName = "__test.allow_unknown";
   TOOL_ARG_SCHEMAS[toolName] = {
@@ -1651,8 +1671,13 @@ test("shares lifecycle schemas enforce deterministic selectors and update requir
     }
   );
 
+  assert.equal(
+    validateToolArgs("shares.update", { id: "share-1", published: "true" }).published,
+    true
+  );
+
   assert.throws(
-    () => validateToolArgs("shares.update", { id: "share-1", published: "true" }),
+    () => validateToolArgs("shares.update", { id: "share-1", published: "yes" }),
     (err) => {
       assert.ok(err instanceof CliError);
       assert.ok(err.details?.issues?.some((issue) => issue.path === "args.published"));

package/test/live.integration.test.js

@@ -1789,11 +1789,6 @@ test("live integration suite (real Outline API, no mocks)", { timeout: 300_000 }
         });
 
         if (run.status !== 0) {
-          if (isApiNotFoundErrorEnvelope(run.stderrJson)) {
-            t.diagnostic(`documents.answer unsupported payload: ${run.stderr || "<empty stderr>"}`);
-            t.skip("documents.answerQuestion endpoint unsupported by this Outline deployment");
-            return;
-          }
           assert.fail(`documents.answer expected success, got status=${run.status}, stderr=${run.stderr || "<empty>"}`);
         }
 
@@ -1805,11 +1800,17 @@ test("live integration suite (real Outline API, no mocks)", { timeout: 300_000 }
         assert.equal(payload.result?.question, happyQuestion);
 
         const signals = extractAnswerSignals(payload.result);
-        assert.ok(
-          signals.answerText.length > 0,
-          `documents.answer happy path should include answer text: ${JSON.stringify(payload.result)}`
-        );
-        assert.ok(Array.isArray(signals.citations), "documents.answer envelope should expose citations array");
+        if (payload.result?.fallbackUsed) {
+          assert.equal(payload.result?.unsupported, true);
+          assert.ok(Array.isArray(signals.citations), "documents.answer fallback should expose citations/documents array");
+          assert.ok(signals.citations.length > 0, `documents.answer fallback should include retrieved docs: ${JSON.stringify(payload.result)}`);
+        } else {
+          assert.ok(
+            signals.answerText.length > 0,
+            `documents.answer happy path should include answer text: ${JSON.stringify(payload.result)}`
+          );
+          assert.ok(Array.isArray(signals.citations), "documents.answer envelope should expose citations array");
+        }
       });
 
       await t.test("documents.answer no-hit path assertions", async (t) => {
@@ -1826,11 +1827,6 @@ test("live integration suite (real Outline API, no mocks)", { timeout: 300_000 }
         });
 
         if (run.status !== 0) {
-          if (isApiNotFoundErrorEnvelope(run.stderrJson)) {
-            t.diagnostic(`documents.answer unsupported payload: ${run.stderr || "<empty stderr>"}`);
-            t.skip("documents.answerQuestion endpoint unsupported by this Outline deployment");
-            return;
-          }
           assert.fail(`documents.answer no-hit expected success, got status=${run.status}, stderr=${run.stderr || "<empty>"}`);
         }
 
@@ -1840,10 +1836,15 @@ test("live integration suite (real Outline API, no mocks)", { timeout: 300_000 }
         assert.equal(payload.result?.question, noHitQuestion);
 
         const signals = extractAnswerSignals(payload.result);
-        assert.ok(
-          signals.noAnswerReason.length > 0 || signals.citations.length === 0 || noHitPattern.test(signals.answerText),
-          `documents.answer no-hit should include explicit no-hit signal: ${JSON.stringify(payload.result)}`
-        );
+        if (payload.result?.fallbackUsed) {
+          assert.equal(payload.result?.unsupported, true);
+          assert.ok(signals.noAnswerReason.length > 0, `documents.answer fallback no-hit should include reason: ${JSON.stringify(payload.result)}`);
+        } else {
+          assert.ok(
+            signals.noAnswerReason.length > 0 || signals.citations.length === 0 || noHitPattern.test(signals.answerText),
+            `documents.answer no-hit should include explicit no-hit signal: ${JSON.stringify(payload.result)}`
+          );
+        }
       });
 
       await t.test("documents.answer_batch mixed questions keep per-item isolation", async (t) => {
@@ -1865,11 +1866,6 @@ test("live integration suite (real Outline API, no mocks)", { timeout: 300_000 }
         });
 
         if (run.status !== 0) {
-          if (isApiNotFoundErrorEnvelope(run.stderrJson)) {
-            t.diagnostic(`documents.answer_batch unsupported payload: ${run.stderr || "<empty stderr>"}`);
-            t.skip("documents.answerQuestion endpoint unsupported by this Outline deployment");
-            return;
-          }
           assert.fail(`documents.answer_batch expected success, got status=${run.status}, stderr=${run.stderr || "<empty>"}`);
         }
 

package/test/profile-selection.unit.test.js

@@ -74,6 +74,17 @@ test("profile selection supports explicit, default, and single-profile fallback
     ]);
     assert.equal(addAlpha.stdoutJson?.defaultProfile, null, "first add should not auto-set default");
 
+    const profileListJson = runCli([
+      "profile",
+      "list",
+      "--config",
+      configPath,
+      "--output",
+      "json",
+    ]);
+    assert.equal(profileListJson.stdoutJson?.ok, true);
+    assert.equal(profileListJson.stdoutJson?.profiles?.length, 1);
+
     const singleFallback = runCli([
       "invoke",
       "no.such.tool",
@@ -105,10 +116,9 @@ test("profile selection supports explicit, default, and single-profile fallback
       "--args",
       "{}",
     ], { expectCode: 1 });
-    assert.match(
-      ambiguous.stderrJson?.error?.message || "",
-      /Profile selection required: multiple profiles are saved and no default profile is set/
-    );
+    assert.match(ambiguous.stderrJson?.error?.message || "", /Unknown tool: no\.such\.tool/);
+    assert.equal(ambiguous.stderrJson?.error?.code, "UNKNOWN_TOOL");
+    assert.ok(Array.isArray(ambiguous.stderrJson?.error?.suggestions));
 
     const explicitProfile = runCli([
       "invoke",

package/test/tool-resolution.unit.test.js

@@ -0,0 +1,333 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { ApiError, CliError } from "../src/errors.js";
+import { getToolContract, invokeTool, resolveToolInvocation } from "../src/tools.js";
+
+test("getToolContract auto-corrects common raw endpoint aliases", () => {
+  const contract = getToolContract("documents.search_titles");
+  assert.equal(contract.name, "documents.search");
+  assert.equal(contract.autoCorrected, true);
+  assert.equal(contract.requestedName, "documents.search_titles");
+  assert.match(contract.reason || "", /mode=titles/);
+});
+
+test("resolveToolInvocation surfaces structured suggestions for unknown tools", () => {
+  assert.throws(
+    () => resolveToolInvocation("document.search"),
+    (err) => {
+      assert.equal(err.name, "CliError");
+      assert.equal(err.details?.code, "UNKNOWN_TOOL");
+      assert.ok(Array.isArray(err.details?.suggestions));
+      assert.ok(err.details.suggestions.some((row) => row.name === "documents.search"));
+      return true;
+    }
+  );
+});
+
+test("invokeTool auto-corrects title-search alias and coerces common JSON string mistakes", async () => {
+  const calls = [];
+  const ctx = {
+    profile: { id: "prod" },
+    client: {
+      async call(method, body) {
+        calls.push({ method, body });
+        return {
+          body: {
+            ok: true,
+            status: 200,
+            data: [
+              {
+                id: "doc-1",
+                title: "Engineering Handbook",
+                collectionId: "col-1",
+                updatedAt: "2026-03-07T00:00:00.000Z",
+                publishedAt: "2026-03-07T00:00:00.000Z",
+                urlId: "abc123",
+                ranking: 0.99,
+                context: "sample context",
+              },
+            ],
+            pagination: { limit: body.limit, offset: body.offset },
+          },
+        };
+      },
+    },
+  };
+
+  const result = await invokeTool(ctx, "documents.searchTitles", {
+    query: ["engineering handbook"],
+    limit: "5",
+    offset: "0",
+    compact: false,
+  });
+
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].method, "documents.search_titles");
+  assert.equal(calls[0].body.query, "engineering handbook");
+  assert.equal(calls[0].body.limit, 5);
+  assert.equal(calls[0].body.offset, 0);
+  assert.equal(result.tool, "documents.search");
+  assert.equal(result.requestedTool, "documents.searchTitles");
+  assert.equal(result.toolResolution?.autoCorrected, true);
+  assert.equal(result.result?.ok, true);
+});
+
+test("documents.list preserves parentDocumentId null for collection root filtering", async () => {
+  const calls = [];
+  const ctx = {
+    profile: { id: "prod" },
+    client: {
+      async call(method, body) {
+        calls.push({ method, body });
+        return {
+          body: {
+            ok: true,
+            status: 200,
+            data: [],
+            pagination: { limit: body.limit, offset: body.offset },
+          },
+        };
+      },
+    },
+  };
+
+  await invokeTool(ctx, "documents.list", {
+    collectionId: "col-1",
+    parentDocumentId: null,
+    limit: 10,
+    compact: false,
+  });
+
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].method, "documents.list");
+  assert.ok(Object.prototype.hasOwnProperty.call(calls[0].body, "parentDocumentId"));
+  assert.equal(calls[0].body.parentDocumentId, null);
+});
+
+test("documents.list rootOnly maps to parentDocumentId null", async () => {
+  const calls = [];
+  const ctx = {
+    profile: { id: "prod" },
+    client: {
+      async call(method, body) {
+        calls.push({ method, body });
+        return {
+          body: {
+            ok: true,
+            status: 200,
+            data: [],
+            pagination: { limit: body.limit, offset: body.offset },
+          },
+        };
+      },
+    },
+  };
+
+  await invokeTool(ctx, "documents.list", {
+    collectionId: "col-1",
+    rootOnly: "true",
+    compact: false,
+  });
+
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].method, "documents.list");
+  assert.ok(Object.prototype.hasOwnProperty.call(calls[0].body, "parentDocumentId"));
+  assert.equal(calls[0].body.parentDocumentId, null);
+});
+
+test("invokeTool enriches arg validation failures with contract hints", async () => {
+  const ctx = {
+    profile: { id: "prod" },
+    client: {
+      async call() {
+        throw new Error("client.call should not run for validation failures");
+      },
+    },
+  };
+
+  await assert.rejects(
+    () => invokeTool(ctx, "docs.answer", { question: "Where?", limt: "3", compact: false }),
+    (err) => {
+      assert.ok(err instanceof CliError);
+      assert.equal(err.details?.code, "ARG_VALIDATION_FAILED");
+      assert.equal(err.details?.tool, "documents.answer");
+      assert.equal(err.details?.requestedTool, "docs.answer");
+      assert.equal(err.details?.toolResolution?.autoCorrected, true);
+      assert.match(err.details?.toolSignature || "", /^documents\.answer\(/);
+      assert.equal(err.details?.usageExample?.tool, "documents.answer");
+      assert.match(err.details?.contractHint || "", /tools contract documents\.answer/);
+      const typoIssue = err.details?.issues?.find((issue) => issue.path === "args.limt");
+      assert.ok(Array.isArray(typoIssue?.suggestions));
+      assert.ok(typoIssue.suggestions.includes("limit"));
+      assert.deepEqual(err.details?.suggestedArgs, {
+        question: "Where?",
+        limit: 3,
+        compact: false,
+      });
+      return true;
+    }
+  );
+});
+
+test("docs.answer alias accepts limit and falls back to deterministic retrieval", async () => {
+  const calls = [];
+  const ctx = {
+    profile: { id: "prod" },
+    client: {
+      async call(method, body) {
+        calls.push({ method, body });
+        if (method === "documents.answerQuestion") {
+          throw new ApiError("Not Found", {
+            status: 404,
+            url: "https://example.com/api/documents.answerQuestion",
+          });
+        }
+        if (method === "documents.search") {
+          return {
+            body: {
+              ok: true,
+              status: 200,
+              data: [
+                {
+                  id: "doc-1",
+                  title: "Engineering / Welcome",
+                  collectionId: "col-1",
+                  updatedAt: "2026-03-07T00:00:00.000Z",
+                  publishedAt: "2026-03-07T00:00:00.000Z",
+                  urlId: "welcome",
+                  ranking: 0.88,
+                  context: "This page helps onboard new engineers.",
+                },
+              ],
+            },
+          };
+        }
+        throw new Error(`Unexpected method: ${method}`);
+      },
+    },
+  };
+
+  const payload = await invokeTool(ctx, "docs.answer", {
+    question: "How do I onboard engineers?",
+    collectionId: "col-1",
+    limit: "3",
+    compact: false,
+  });
+
+  assert.equal(calls[0].method, "documents.answerQuestion");
+  assert.equal(calls[0].body.limit, undefined);
+  assert.equal(calls[1].method, "documents.search");
+  assert.equal(calls[1].body.limit, 3);
+  assert.equal(payload.tool, "documents.answer");
+  assert.equal(payload.requestedTool, "docs.answer");
+  assert.equal(payload.toolResolution?.autoCorrected, true);
+  assert.equal(payload.result?.fallbackUsed, true);
+  assert.equal(payload.result?.unsupported, true);
+  assert.equal(payload.result?.fallbackTool, "documents.search");
+  assert.equal(payload.result?.question, "How do I onboard engineers?");
+  assert.deepEqual(payload.result?.fallbackSuggestion, {
+    tool: "documents.search",
+    args: {
+      query: "How do I onboard engineers?",
+      collectionId: "col-1",
+      limit: 3,
+      view: "summary",
+    },
+  });
+  assert.ok(Array.isArray(payload.result?.documents));
+  assert.equal(payload.result.documents[0]?.title, "Engineering / Welcome");
+  assert.match(payload.result?.noAnswerReason || "", /unsupported/i);
+});
+
+test("documents.info summary redacts obvious credentials in excerpts", async () => {
+  const ctx = {
+    profile: { id: "prod" },
+    client: {
+      async call() {
+        return {
+          body: {
+            ok: true,
+            status: 200,
+            data: {
+              id: "doc-1",
+              title: "Keycloak",
+              collectionId: "col-1",
+              revision: 3,
+              updatedAt: "2026-03-07T00:00:00.000Z",
+              publishedAt: "2026-03-07T00:00:00.000Z",
+              urlId: "keycloak",
+              text: [
+                "Site: https://idp.example.com",
+                "User / Pass: dev / qUHxy1auV5E7",
+                "* **Credentials**: `test@yopmail.com` / `xxxxyyyy`",
+                "API key: ol_api_abcdef123456",
+                "Git Repo: https://dev:supersecret@example.com/repo",
+              ].join("\n"),
+            },
+          },
+        };
+      },
+    },
+  };
+
+  const payload = await invokeTool(ctx, "documents.info", {
+    id: "doc-1",
+    view: "summary",
+    compact: false,
+  });
+
+  const excerpt = payload.result?.data?.excerpt || "";
+  assert.match(excerpt, /User \/ Pass: \[REDACTED\]/);
+  assert.match(excerpt, /\* \*\*Credentials\*\*: \[REDACTED\]/);
+  assert.match(excerpt, /API key: \[REDACTED\]/i);
+  assert.match(excerpt, /https:\/\/\[REDACTED\]@example\.com\/repo/);
+  assert.ok(!excerpt.includes("qUHxy1auV5E7"));
+  assert.ok(!excerpt.includes("xxxxyyyy"));
+  assert.ok(!excerpt.includes("ol_api_abcdef123456"));
+});
+
+test("documents.search summary redacts obvious credentials in contexts", async () => {
+  const ctx = {
+    profile: { id: "prod" },
+    client: {
+      async call(method) {
+        assert.equal(method, "documents.search");
+        return {
+          body: {
+            ok: true,
+            status: 200,
+            data: [
+              {
+                document: {
+                  id: "doc-1",
+                  title: "Keycloak",
+                  collectionId: "col-1",
+                  updatedAt: "2026-03-07T00:00:00.000Z",
+                  publishedAt: "2026-03-07T00:00:00.000Z",
+                  urlId: "keycloak",
+                },
+                ranking: 0.9,
+                context:
+                  "* **Credentials**: dev / secretpass\nAPI key: ol_api_searchsecret\nURL: https://dev:pass@example.com/repo",
+              },
+            ],
+          },
+        };
+      },
+    },
+  };
+
+  const payload = await invokeTool(ctx, "documents.search", {
+    query: "keycloak",
+    view: "summary",
+    compact: false,
+  });
+
+  const context = payload.result?.data?.[0]?.context || "";
+  assert.match(context, /\* \*\*Credentials\*\*: \[REDACTED\]/);
+  assert.match(context, /API key: \[REDACTED\]/i);
+  assert.match(context, /https:\/\/\[REDACTED\]@example\.com\/repo/);
+  assert.ok(!context.includes("secretpass"));
+  assert.ok(!context.includes("ol_api_searchsecret"));
+});

package/test/version.unit.test.js

@@ -0,0 +1,21 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = path.resolve(__dirname, "..");
+const packageJson = JSON.parse(fs.readFileSync(path.join(repoRoot, "package.json"), "utf8"));
+
+test("outline-cli --version matches package.json", () => {
+  const result = spawnSync("node", [path.join(repoRoot, "bin/outline-cli.js"), "--version"], {
+    cwd: repoRoot,
+    encoding: "utf8",
+  });
+
+  assert.equal(result.status, 0, result.stderr);
+  assert.equal(result.stdout.trim(), packageJson.version);
+});