@khanglvm/outline-cli 0.1.2 → 0.1.4

package/src/config-store.js

@@ -2,6 +2,7 @@ import fs from "node:fs/promises";
 import fsSync from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { CliError } from "./errors.js";
 
 export const CONFIG_VERSION = 1;
 
@@ -479,6 +480,45 @@ export function suggestProfiles(config, query, options = {}) {
   };
 }
 
+function isHighConfidenceProfileMatch(top, second, options = {}) {
+  if (!top) {
+    return false;
+  }
+
+  const minScore = Number.isFinite(Number(options.minScore)) ? Number(options.minScore) : 1.7;
+  const minGap = Number.isFinite(Number(options.minGap)) ? Number(options.minGap) : 0.55;
+  const exactSignals = new Set(["id_exact", "name_exact", "keyword_exact", "host"]);
+  const hasExactSignal = Array.isArray(top.matchedOn) && top.matchedOn.some((item) => exactSignals.has(item));
+  const gap = top.score - Number(second?.score || 0);
+
+  if (top.score >= 3.2) {
+    return true;
+  }
+  if (top.score >= minScore && gap >= minGap) {
+    return true;
+  }
+  if (hasExactSignal && top.score >= 1.2 && gap >= 0.35) {
+    return true;
+  }
+
+  return false;
+}
+
+function formatProfileSelectionError(config, message, options = {}) {
+  const availableProfiles = Object.keys(config?.profiles || {});
+  const query = String(options.query || "").trim();
+  const suggestionLimit = Number.isFinite(Number(options.suggestionLimit))
+    ? Math.max(1, Number(options.suggestionLimit))
+    : 3;
+  const suggestions = query ? suggestProfiles(config, query, { limit: suggestionLimit }).matches : [];
+
+  return new CliError(message, {
+    code: "PROFILE_SELECTION_REQUIRED",
+    availableProfiles,
+    ...(query ? { query, suggestions } : {}),
+  });
+}
+
 export function suggestProfileMetadata(input = {}, options = {}) {
   const id = String(input.id || "").trim();
   const name = String(input.name || id || "").trim();
@@ -566,13 +606,17 @@ export function listProfiles(config) {
   }));
 }
 
-export function getProfile(config, explicitId) {
+export function getProfile(config, explicitId, options = {}) {
   const profiles = config?.profiles || {};
 
   if (explicitId) {
     const profile = profiles[explicitId];
     if (!profile) {
-      throw new Error(`Profile not found: ${explicitId}`);
+      throw new CliError(`Profile not found: ${explicitId}`, {
+        code: "PROFILE_NOT_FOUND",
+        profileId: explicitId,
+        availableProfiles: Object.keys(profiles),
+      });
     }
     return {
       id: explicitId,
@@ -583,7 +627,11 @@ export function getProfile(config, explicitId) {
   if (config.defaultProfile) {
     const profile = profiles[config.defaultProfile];
     if (!profile) {
-      throw new Error(`Profile not found: ${config.defaultProfile}`);
+      throw new CliError(`Profile not found: ${config.defaultProfile}`, {
+        code: "PROFILE_NOT_FOUND",
+        profileId: config.defaultProfile,
+        availableProfiles: Object.keys(profiles),
+      });
     }
     return {
       id: config.defaultProfile,
@@ -601,12 +649,44 @@ export function getProfile(config, explicitId) {
   }
 
   if (profileIds.length > 1) {
-    throw new Error(
-      "Profile selection required: multiple profiles are saved and no default profile is set. Use --profile <id> or `outline-cli profile use <id>`."
+    const query = String(options.query || "").trim();
+    const allowAutoSelect = options.allowAutoSelect !== false;
+    const suggestionLimit = Number.isFinite(Number(options.suggestionLimit))
+      ? Math.max(1, Number(options.suggestionLimit))
+      : 3;
+
+    if (allowAutoSelect && query) {
+      const suggestions = suggestProfiles(config, query, { limit: suggestionLimit }).matches;
+      const top = suggestions[0];
+      const second = suggestions[1];
+
+      if (isHighConfidenceProfileMatch(top, second, options)) {
+        return {
+          id: top.id,
+          ...profiles[top.id],
+          selection: {
+            autoSelected: true,
+            query,
+            score: top.score,
+            matchedOn: top.matchedOn,
+          },
+        };
+      }
+    }
+
+    throw formatProfileSelectionError(
+      config,
+      "Profile selection required: multiple profiles are saved and no default profile is set. Use --profile <id> or `outline-cli profile use <id>`.",
+      {
+        query,
+        suggestionLimit,
+      }
     );
   }
 
-  throw new Error("No profiles configured. Use `outline-cli profile add <id> ...` first.");
+  throw new CliError("No profiles configured. Use `outline-cli profile add <id> ...` first.", {
+    code: "PROFILE_NOT_CONFIGURED",
+  });
 }
 
 export function redactProfile(profile) {

package/src/entry-integrity-manifest.generated.js

@@ -3,8 +3,8 @@ export const ENTRY_INTEGRITY_MANIFEST = Object.freeze({
   version: 1,
   algorithm: "sha256",
   signatureAlgorithm: "sha256-salted-manifest-v1",
-  signature: "db2b8cd3d150b5be3b17246af7a254fc42ec500c3567a8be79ca2e4178f4657a",
-  generatedAt: "2026-03-06T00:27:55.266Z",
+  signature: "c69d41948b78c8ae35c0223377149ece8df5588863a010adf92a0b6ad11876d3",
+  generatedAt: "2026-03-07T12:16:27.340Z",
   files: [
   {
     "path": "src/action-gate.js",
@@ -12,19 +12,19 @@ export const ENTRY_INTEGRITY_MANIFEST = Object.freeze({
   },
   {
     "path": "src/agent-skills.js",
-    "sha256": "3ec649a1e4fb475de47882223d2ca0e5bb049720cad1b456ea3ecd6ff1b74ecc"
+    "sha256": "d40e94a4b61922d3ee8a43ed89d5e9ce1562a2cdffd37e2f396c2a18b9a481fc"
   },
   {
     "path": "src/cli.js",
-    "sha256": "bf37837390eaedadc6f8a8a8e279e61c12d56792f83cb4c53173439009cf5422"
+    "sha256": "2b6b17a71c15954c2663397d57afde2b8825ed368bb7f71833f6191662eff079"
   },
   {
     "path": "src/config-store.js",
-    "sha256": "e0d62083c694f84895a93752738accbbd98830157227f06380ccdf8e421508fd"
+    "sha256": "3773d59d74502c75b7375c194b4f0e2c39fb43e95f739e6e4878aa1b0957a511"
   },
   {
     "path": "src/entry-integrity.js",
-    "sha256": "3463fc3a3c6d0aead8e889ecce7c323b64b09ef54c772c52ff8b7266eb8c0d69"
+    "sha256": "5f66c29e57f53f11fc1751c9a8bd41c318001e3fb6562ee6f3a593f31849e45e"
   },
   {
     "path": "src/errors.js",
@@ -42,25 +42,29 @@ export const ENTRY_INTEGRITY_MANIFEST = Object.freeze({
     "path": "src/secure-keyring.js",
     "sha256": "370d904265733f7d6b0f47b3213c7f026c95e59bc18d364dff96be90dbd7f479"
   },
+  {
+    "path": "src/summary-redaction.js",
+    "sha256": "ddd3562334e704de5d9f6068726e311a98564e7e46bcdb56d9aade7e63b65bd3"
+  },
   {
     "path": "src/tool-arg-schemas.js",
-    "sha256": "de6f389349d6688296a8e66d2d612937f31b4fc2a0efdca085d36ec5b09cab26"
+    "sha256": "51f8727255e5b2b0a4cce78495cfaed9bb1869a7ef104b22dbc170604f878feb"
   },
   {
     "path": "src/tools.extended.js",
-    "sha256": "8f29601301c7942cce8884c689916a78a22231e5f6691ecebfe09d9d4f87d6c3"
+    "sha256": "0c5317ca0b28a0b7110d9e6c81d8ca6ccd705e9b303de2f29e03f847b31df310"
   },
   {
     "path": "src/tools.js",
-    "sha256": "bfcb36045abecc758237ce9441d7e5994a4467893b09d48557749a90de424401"
+    "sha256": "96cfbb14cac2baa5221dc4e9294a0520f81c3e22a0c69ee648cd6c2354e1512e"
   },
   {
     "path": "src/tools.mutation.js",
-    "sha256": "013cee7d9815f868cca8990af39abe385239fa0f324054477d681e479605e903"
+    "sha256": "15fa3d146d99f55bc16d814ffd9360127b99eca2f9271cf751c6e5c7e4234317"
   },
   {
     "path": "src/tools.navigation.js",
-    "sha256": "8cd6ad37db2ef4d8a2ddd2eea408c8ab50b5649b620680cef07bd8f3ecea7e89"
+    "sha256": "f7118e91c2edd0e6b57591d41fe7707c68eef51cde77918495bb4ee166139339"
   },
   {
     "path": "src/tools.platform.js",

package/src/entry-integrity.js

@@ -52,6 +52,7 @@ export async function assertEntryIntegrity(rootDir = REPO_ROOT) {
   if (files.length === 0) {
     throw new CliError("Entry integrity manifest is empty", {
       code: "ENTRY_INTEGRITY_MANIFEST_EMPTY",
+      hint: "Run `npm run integrity:refresh` to regenerate local integrity metadata.",
     });
   }
 
@@ -62,6 +63,7 @@ export async function assertEntryIntegrity(rootDir = REPO_ROOT) {
       expected: manifest.signature,
       actual: computedSignature,
       keyId: ENTRY_INTEGRITY_BINDING.keyId,
+      hint: "Run `npm run integrity:refresh` after local source edits, or set `OUTLINE_CLI_SKIP_INTEGRITY_CHECK=1` for local smoke runs.",
     });
   }
 
@@ -93,6 +95,7 @@ export async function assertEntryIntegrity(rootDir = REPO_ROOT) {
       code: "ENTRY_SUBMODULE_INTEGRITY_FAILED",
       mismatchCount: mismatches.length,
       mismatches,
+      hint: "Run `npm run integrity:refresh` after local source edits, or set `OUTLINE_CLI_SKIP_INTEGRITY_CHECK=1` for local smoke runs.",
     });
   }
 

package/src/summary-redaction.js

@@ -0,0 +1,37 @@
+const SUMMARY_SECRET_LINE_PATTERNS = [
+  /(^|\n)([ \t>*+\-]*(?:[*_`~]+\s*)*(?:user(?:name)?\s*\/\s*pass(?:word)?|username\s*\/\s*password|credentials?|api[ _-]*key|access[ _-]*token|refresh[ _-]*token|client[ _-]*secret|secret|password|pass|pwd|authorization|bearer)(?:\s*[*_`~]+)*\s*:\s*)([^\n]+)/gi,
+  /(^|\n)([ \t>*+\-]*(?:[*_`~]+\s*)*(?:user(?:name)?|email|login)(?:\s*[*_`~]+)*\s*:\s*)([^\n]+)(\n[ \t>*+\-]*(?:[*_`~]+\s*)*(?:pass(?:word)?|pwd)(?:\s*[*_`~]+)*\s*:\s*)([^\n]+)/gi,
+];
+
+export function redactSensitiveSummaryText(text) {
+  if (typeof text !== "string" || text.length === 0) {
+    return text;
+  }
+
+  let redacted = text;
+  for (const pattern of SUMMARY_SECRET_LINE_PATTERNS) {
+    redacted = redacted.replace(pattern, (...parts) => {
+      const leading = parts[1] || "";
+      const prefix = parts[2] || "";
+      const secondPrefix = parts[4];
+      if (typeof secondPrefix === "string") {
+        return `${leading}${prefix}[REDACTED]${secondPrefix}[REDACTED]`;
+      }
+      return `${leading}${prefix}[REDACTED]`;
+    });
+  }
+
+  redacted = redacted.replace(/\bol_api_[A-Za-z0-9]+\b/g, "ol_api_[REDACTED]");
+  redacted = redacted.replace(/\b(?:ghp|gho|ghu|ghs|github_pat|sk|pk)_[A-Za-z0-9_]+\b/g, "[REDACTED_TOKEN]");
+  redacted = redacted.replace(/(https?:\/\/)([^\s:@/]+):([^\s@/]+)@/gi, "$1[REDACTED]@");
+
+  return redacted;
+}
+
+export function summarizeSafeText(text, maxChars) {
+  const redacted = redactSensitiveSummaryText(text);
+  if (typeof redacted !== "string") {
+    return redacted;
+  }
+  return redacted.length > maxChars ? `${redacted.slice(0, maxChars)}...` : redacted;
+}

package/src/tool-arg-schemas.js

@@ -11,12 +11,8 @@ const TYPES = {
   "string|string[]": (v) => typeof v === "string" || (Array.isArray(v) && v.every((x) => typeof x === "string")),
 };
 
-function fail(tool, issues) {
-  throw new CliError(`Invalid args for ${tool}`, {
-    code: "ARG_VALIDATION_FAILED",
-    tool,
-    issues,
-  });
+function fail(tool, issues, spec = {}, args = undefined) {
+  throw new CliError(`Invalid args for ${tool}`, buildValidationDetails(tool, spec, issues, args));
 }
 
 function ensureObject(tool, args) {
@@ -25,7 +21,248 @@ function ensureObject(tool, args) {
   }
 }
 
-function validateSpec(tool, args, spec) {
+function levenshteinDistance(a, b) {
+  const left = String(a || "");
+  const right = String(b || "");
+  const rows = left.length + 1;
+  const cols = right.length + 1;
+  const matrix = Array.from({ length: rows }, () => Array(cols).fill(0));
+
+  for (let i = 0; i < rows; i += 1) {
+    matrix[i][0] = i;
+  }
+  for (let j = 0; j < cols; j += 1) {
+    matrix[0][j] = j;
+  }
+
+  for (let i = 1; i < rows; i += 1) {
+    for (let j = 1; j < cols; j += 1) {
+      const cost = left[i - 1] === right[j - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(
+        matrix[i - 1][j] + 1,
+        matrix[i][j - 1] + 1,
+        matrix[i - 1][j - 1] + cost
+      );
+    }
+  }
+
+  return matrix[rows - 1][cols - 1];
+}
+
+function buildAcceptedArgList(spec = {}) {
+  const accepted = new Set(Object.keys(spec.properties || {}));
+  accepted.add("compact");
+  return [...accepted].sort();
+}
+
+function suggestClosestArgNames(key, acceptedArgs) {
+  const raw = String(key || "").trim();
+  if (!raw) {
+    return [];
+  }
+
+  return acceptedArgs
+    .map((candidate) => ({
+      candidate,
+      distance: levenshteinDistance(raw.toLowerCase(), String(candidate).toLowerCase()),
+    }))
+    .filter((row) => row.distance <= 3)
+    .sort((a, b) => a.distance - b.distance || a.candidate.localeCompare(b.candidate))
+    .slice(0, 3)
+    .map((row) => row.candidate);
+}
+
+function enrichIssuesWithArgSuggestions(issues, acceptedArgs) {
+  return issues.map((issue) => {
+    if (!issue || issue.message !== "is not allowed" || typeof issue.path !== "string") {
+      return issue;
+    }
+    const key = issue.path.startsWith("args.") ? issue.path.slice(5) : issue.path;
+    const suggestions = suggestClosestArgNames(key, acceptedArgs);
+    return suggestions.length > 0 ? { ...issue, suggestions } : issue;
+  });
+}
+
+function extractArgKeyFromIssue(issue) {
+  if (!issue || typeof issue.path !== "string") {
+    return null;
+  }
+  return issue.path.startsWith("args.") ? issue.path.slice(5) : issue.path;
+}
+
+function applySuggestedArgFixes(args, issues) {
+  if (!args || typeof args !== "object" || Array.isArray(args)) {
+    return undefined;
+  }
+
+  const next = { ...args };
+  let changed = false;
+
+  for (const issue of issues) {
+    if (!issue || issue.message !== "is not allowed") {
+      continue;
+    }
+    const key = extractArgKeyFromIssue(issue);
+    const target = Array.isArray(issue.suggestions) && issue.suggestions.length > 0
+      ? issue.suggestions[0]
+      : null;
+    if (!key || !target || !(key in next) || key === target) {
+      continue;
+    }
+    if (target in next && next[target] !== next[key]) {
+      continue;
+    }
+    if (!(target in next)) {
+      next[target] = next[key];
+    }
+    delete next[key];
+    changed = true;
+  }
+
+  return changed ? next : undefined;
+}
+
+function buildSuggestedArgs(spec, args, enrichedIssues) {
+  const candidate = applySuggestedArgFixes(args, enrichedIssues);
+  if (!candidate) {
+    return undefined;
+  }
+
+  const normalized = normalizeArgsForSpec(candidate, spec);
+  const remainingIssues = collectValidationIssues(normalized, spec);
+  return remainingIssues.length === 0 ? normalized : undefined;
+}
+
+function buildValidationDetails(tool, spec, issues, args = undefined) {
+  const acceptedArgs = buildAcceptedArgList(spec);
+  const enrichedIssues = enrichIssuesWithArgSuggestions(issues, acceptedArgs);
+  const requiredArgs = [...new Set(spec.required || [])].sort();
+  const unknownArgs = enrichedIssues
+    .filter((issue) => issue?.message === "is not allowed" && typeof issue.path === "string")
+    .map((issue) => issue.path.replace(/^args\./, ""));
+  const suggestedArgs = buildSuggestedArgs(spec, args, enrichedIssues);
+
+  return {
+    code: "ARG_VALIDATION_FAILED",
+    tool,
+    issues: enrichedIssues,
+    acceptedArgs,
+    requiredArgs,
+    unknownArgs,
+    suggestedArgs,
+    validationHint:
+      acceptedArgs.length > 0 ? `Accepted args: ${acceptedArgs.join(", ")}` : undefined,
+  };
+}
+
+function looksNumeric(value) {
+  return /^-?(?:\d+|\d+\.\d+)$/.test(String(value || "").trim());
+}
+
+function coerceScalarValue(types, value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return value;
+  }
+
+  if (types.includes("boolean") && /^(true|false)$/i.test(trimmed)) {
+    return trimmed.toLowerCase() === "true";
+  }
+  if (types.includes("null") && /^null$/i.test(trimmed)) {
+    return null;
+  }
+  if (types.includes("number") && looksNumeric(trimmed)) {
+    return Number(trimmed);
+  }
+  if (types.includes("object") && /^[{]/.test(trimmed)) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return value;
+    }
+  }
+  if (types.includes("array") && /^[[]/.test(trimmed)) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return value;
+    }
+  }
+
+  return value;
+}
+
+function coerceArrayValue(types, value) {
+  if (!Array.isArray(value)) {
+    if (types.includes("string[]") && typeof value === "string") {
+      return [value];
+    }
+    return value;
+  }
+
+  if (types.includes("string[]")) {
+    return value.map((item) => (typeof item === "string" ? item : String(item)));
+  }
+
+  return value;
+}
+
+function normalizeCrossFieldAliases(args, properties) {
+  const next = { ...args };
+
+  if (Array.isArray(next.query) && properties.queries && next.queries === undefined) {
+    next.queries = next.query.map((item) => String(item));
+    delete next.query;
+  }
+  if (Array.isArray(next.question) && properties.questions && next.questions === undefined) {
+    next.questions = next.question.map((item) => String(item));
+    delete next.question;
+  }
+  if (Array.isArray(next.id) && properties.ids && next.ids === undefined) {
+    next.ids = next.id.map((item) => String(item));
+    delete next.id;
+  }
+  if (typeof next.ids === "string" && properties.id && !properties.ids && next.id === undefined) {
+    next.id = next.ids;
+    delete next.ids;
+  }
+  if (typeof next.queries === "string" && properties.query && !properties.queries && next.query === undefined) {
+    next.query = next.queries;
+    delete next.queries;
+  }
+
+  return next;
+}
+
+function normalizeArgsForSpec(args, spec) {
+  const properties = spec.properties || {};
+  const next = normalizeCrossFieldAliases(args, properties);
+
+  for (const [key, rule] of Object.entries(properties)) {
+    if (!(key in next)) {
+      continue;
+    }
+
+    const types = Array.isArray(rule.type) ? rule.type : [rule.type];
+    let value = next[key];
+    value = coerceArrayValue(types, value);
+    value = coerceScalarValue(types, value);
+
+    if (Array.isArray(value) && types.includes("string[]")) {
+      value = value.map((item) => (typeof item === "string" ? item : String(item)));
+    }
+
+    next[key] = value;
+  }
+
+  return next;
+}
+
+function collectValidationIssues(args, spec) {
   const issues = [];
   const properties = spec.properties || {};
 
@@ -81,8 +318,14 @@ function validateSpec(tool, args, spec) {
     spec.custom(args, issues);
   }
 
+  return issues;
+}
+
+function validateSpec(tool, args, spec) {
+  const issues = collectValidationIssues(args, spec);
+
   if (issues.length > 0) {
-    fail(tool, issues);
+    fail(tool, issues, spec, args);
   }
 }
 
@@ -151,10 +394,19 @@ export const TOOL_ARG_SCHEMAS = {
       sort: { type: "string" },
       direction: { type: "string", enum: ["ASC", "DESC"] },
       parentDocumentId: { type: ["string", "null"] },
+      rootOnly: { type: "boolean" },
       backlinkDocumentId: { type: "string" },
       includePolicies: { type: "boolean" },
       ...SHARED_DOC_COMMON,
     },
+    custom(args, issues) {
+      if (args.rootOnly === true && Object.prototype.hasOwnProperty.call(args, "parentDocumentId") && args.parentDocumentId !== null) {
+        issues.push({
+          path: "args.rootOnly",
+          message: "cannot be combined with a non-null args.parentDocumentId",
+        });
+      }
+    },
   },
   "documents.backlinks": {
     required: ["id"],
@@ -2245,6 +2497,7 @@ export const TOOL_ARG_SCHEMAS = {
       dateFilter: { type: "string", enum: ["day", "week", "month", "year"] },
       includePolicies: { type: "boolean" },
       includeEvidenceDocs: { type: "boolean" },
+      limit: { type: "number", min: 1 },
       view: { type: "string", enum: ["summary", "full"] },
       maxAttempts: { type: "number", min: 1 },
     },
@@ -2267,6 +2520,7 @@ export const TOOL_ARG_SCHEMAS = {
       dateFilter: { type: "string", enum: ["day", "week", "month", "year"] },
       includePolicies: { type: "boolean" },
       includeEvidenceDocs: { type: "boolean" },
+      limit: { type: "number", min: 1 },
       view: { type: "string", enum: ["summary", "full"] },
       concurrency: { type: "number", min: 1 },
       maxAttempts: { type: "number", min: 1 },
@@ -2338,9 +2592,11 @@ export const TOOL_ARG_SCHEMAS = {
 export function validateToolArgs(toolName, args = {}) {
   const spec = TOOL_ARG_SCHEMAS[toolName];
   if (!spec) {
-    return;
+    return args;
   }
 
   ensureObject(toolName, args);
-  validateSpec(toolName, args, spec);
+  const normalizedArgs = normalizeArgsForSpec(args, spec);
+  validateSpec(toolName, normalizedArgs, spec);
+  return normalizedArgs;
 }