caveat-cli 0.20.2 → 0.20.3

package/dist/index.js

@@ -7,6 +7,9 @@ import {
   CAVEAT_AUTO_SYNC_ENV,
   KNOWLEDGE_GITIGNORE,
   PublishScanError,
+  SyncError,
+  SyncRecoveryError,
+  SyncRemoteError,
   __commonJS,
   __export,
   __toESM,
@@ -84,7 +87,7 @@ import {
   writeDigestMarker,
   writeJevObservation,
   writeUserConfigPatch
-} from "./chunk-JYXVT46B.js";
+} from "./chunk-TGIVITP4.js";
 
 // ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS({
@@ -7728,17 +7731,19 @@ function diagnoseCursorHookConnector(cursorDir, nodePath, cliScriptPath) {
 // src/ghSetup.ts
 import { spawnSync } from "node:child_process";
 import { readSync } from "node:fs";
+var RepoSetupError = class extends Error {
+};
 function runGh(args) {
   const result = spawnSync("gh", args, { encoding: "utf-8" });
   return { status: result.status, stdout: typeof result.stdout === "string" ? result.stdout : "", stderr: typeof result.stderr === "string" ? result.stderr : "" };
 }
 function commandError(result, fallback) {
-  return new Error((result.stderr || result.stdout || fallback).trim());
+  return new RepoSetupError((result.stderr || result.stdout || fallback).trim());
 }
 function defaultGitHubRepoUrl(opts) {
   const version2 = opts.ghRunner(["--version"]);
   if (version2.status !== 0) {
-    throw new Error(
+    throw new RepoSetupError(
       `gh is not available. create a ${opts.visibility} repository named ${opts.repositoryName} on GitHub, then run:
   ${opts.retryCommand}
   # or install gh and retry`
@@ -7746,7 +7751,7 @@ function defaultGitHubRepoUrl(opts) {
   }
   const user = opts.ghRunner(["api", "user", "-q", ".login"]);
   if (user.status !== 0 || !user.stdout.trim()) {
-    throw new Error(`gh is not authenticated; run \`gh auth login\`, then retry \`${opts.retryCommand}\``);
+    throw new RepoSetupError(`gh is not authenticated; run \`gh auth login\`, then retry \`${opts.retryCommand}\``);
   }
   const login = user.stdout.trim();
   const setupGit = opts.ghRunner(["auth", "setup-git"]);
@@ -7759,9 +7764,9 @@ function defaultGitHubRepoUrl(opts) {
     const question = `create ${opts.visibility} repo github.com/${qualifiedName}? [y/N]`;
     if (!opts.yes) {
       if (!opts.isTty()) {
-        throw new Error(`${question}; rerun with --yes to approve non-interactively`);
+        throw new RepoSetupError(`${question}; rerun with --yes to approve non-interactively`);
       }
-      if (!opts.confirm(question)) throw new Error(`${opts.visibility} repository creation cancelled`);
+      if (!opts.confirm(question)) throw new RepoSetupError(`${opts.visibility} repository creation cancelled`);
     }
     const create = opts.ghRunner(["repo", "create", opts.repositoryName, `--${opts.visibility}`]);
     if (create.status !== 0) throw commandError(create, "gh repo create failed");
@@ -8230,7 +8235,7 @@ async function runIndex(ctx, opts) {
   try {
     db = openDb({ path: ctx.paths.dbPath, logger: ctx.logger });
   } catch (error51) {
-    observeRuntimeError("CAVEAT.DATABASE_OPEN_FAILED", { version: CAVEAT_VERSION });
+    observeRuntimeError("CAVEAT.DATABASE_OPEN_FAILED", { version: CAVEAT_VERSION, impact: "feature_unavailable" });
     throw error51;
   }
   try {
@@ -8248,7 +8253,7 @@ async function runIndex(ctx, opts) {
     }
     writeDigestMarker(ctx.caveatHome, computeEntriesDigest(ctx.paths));
   } catch (error51) {
-    observeRuntimeError("CAVEAT.INDEX_FAILED", { version: CAVEAT_VERSION });
+    observeRuntimeError("CAVEAT.INDEX_FAILED", { version: CAVEAT_VERSION, impact: "feature_unavailable" });
     throw error51;
   } finally {
     db.close();
@@ -8404,7 +8409,7 @@ function runStats(ctx) {
 
 // src/commands/serve.ts
 async function runServe(opts) {
-  const { startServer } = await import("./server-XI7ZOMPY.js");
+  const { startServer } = await import("./server-A3BKQOHZ.js");
   const { port, host } = startServer({ port: opts.port });
   process.stdout.write(`[caveat] web portal: http://${host}:${port}/
 `);
@@ -32693,12 +32698,12 @@ function expectedControlFlow(error51) {
   const message = error51 instanceof Error ? error51.message : "";
   return /^caveat not found:/.test(message) || /^community エントリは購読物/.test(message) || /^immutable frontmatter key:/.test(message);
 }
-function observeToolFailure(handler, productVersion = "0.0.0") {
+function observeToolFailure(handler, productVersion = "0.0.0", impact = "operation_failed") {
   return async (args) => {
     try {
       return jsonResult(await handler(args));
     } catch (error51) {
-      if (!expectedControlFlow(error51)) observeRuntimeError("CAVEAT.MCP_TOOL_FAILED", { version: productVersion });
+      if (!expectedControlFlow(error51)) observeRuntimeError("CAVEAT.MCP_TOOL_FAILED", { version: productVersion, impact });
       throw error51;
     }
   };
@@ -32729,7 +32734,7 @@ function registerAllTools(server, ctx, productVersion = "0.0.0") {
       description: "Create a new caveat: a reusable record of a time-wasting trap (wrong driver, version mismatch, platform bug, IDE quirk, native-module issue, or repo-specific context) so future sessions can find it via caveat_search. REQUIRED BEFORE CALLING: run caveat_search first to avoid duplicates. Set visibility using this binary criterion: `public` if a third party could reproduce it; `private` if it is repo/workflow-specific or depends on intentional local design; when unclear, prefer `private`; follow an explicit user visibility choice. Qualifies: specific symptom + diagnosed cause (or `outcome: impossible` verdict) + environment fingerprint. Does NOT qualify: ordinary project-internal logic bugs, user preferences, session summaries, or ephemeral task notes; reusable repo-specific traps may be `private`. Auto-fills source_session and environment defaults; source_project is left null by design (shared knowledge must not leak per-user project names).",
       inputSchema: recordInputShape
     },
-    observeToolFailure((args) => handleRecord(ctx, args), productVersion)
+    observeToolFailure((args) => handleRecord(ctx, args), productVersion, "mutation_outcome_unverified")
   );
   server.registerTool(
     "caveat_update",
@@ -32738,7 +32743,7 @@ function registerAllTools(server, ctx, productVersion = "0.0.0") {
       description: "Patch an existing caveat \u2014 use when newer evidence extends or corrects one that already exists. Frontmatter shallow-merges, but array fields (tags etc.) REPLACE rather than append \u2014 to add one tag, read the current list first, then patch with the full new array. Sections match by case-insensitive H2 heading. When changing `Symptom`, preserve raw errors verbatim and add stable Japanese/English symptom keywords when known; do not force or guess translations. Immutable keys: id, created_at, source_session, source_project. Common uses: bump `last_verified` after re-confirming, add a resolution when it was `tentative`, flip `outcome` to `impossible`.",
       inputSchema: updateInputShape
     },
-    observeToolFailure((args) => handleUpdate(ctx, args), productVersion)
+    observeToolFailure((args) => handleUpdate(ctx, args), productVersion, "mutation_outcome_unverified")
   );
   server.registerTool(
     "caveat_list_recent",
@@ -32796,7 +32801,7 @@ async function runMcpServer() {
   try {
     await startMcpStdioServer({ productVersion: CAVEAT_VERSION });
   } catch (error51) {
-    observeRuntimeError("CAVEAT.MCP_SERVER_FAILED", { version: CAVEAT_VERSION });
+    observeRuntimeError("CAVEAT.MCP_SERVER_FAILED", { version: CAVEAT_VERSION, impact: "feature_unavailable" });
     throw error51;
   }
 }
@@ -32950,7 +32955,10 @@ function errorMessage4(err) {
   return err instanceof Error ? err.message : String(err);
 }
 function reportHookError(host, phase, err) {
-  observeRuntimeError(host.errorCode, { version: CAVEAT_VERSION });
+  observeRuntimeError(host.errorCode, {
+    version: CAVEAT_VERSION,
+    impact: phase === "markHit error" || phase === "query log error" || phase === "json parse error" ? "operation_failed" : "feature_unavailable"
+  });
   observeHookDiagnostic(host.errorCode, phase, err, { version: CAVEAT_VERSION });
   process.stderr.write(`[${host.stderrTag}] ${phase}: ${errorMessage4(err)}
 `);
@@ -34528,7 +34536,15 @@ async function runSync(ctx, opts, dependencies = {}) {
       }
     }
   } catch (err) {
-    observeRuntimeError("CAVEAT.SYNC_FAILED", { version: CAVEAT_VERSION });
+    if (!(err instanceof RepoSetupError || err instanceof SyncError || err instanceof SyncRemoteError)) {
+      observeRuntimeError("CAVEAT.SYNC_FAILED", {
+        version: CAVEAT_VERSION,
+        impact: err instanceof SyncRecoveryError ? "recovery_failed" : "operation_failed"
+      });
+      ctx.logger.warn("sync did not complete; cause and recovery require investigation");
+    }
+    if (err instanceof SyncRemoteError) ctx.logger.warn(`sync remote command failed (${err.phase}); cause unconfirmed; local input retained; retry checks remote state`);
+    if (err instanceof SyncRecoveryError) ctx.logger.warn("sync recovery is unverified; do not retry before inspecting the rebase");
     const message = err instanceof Error ? err.message : String(err);
     ctx.logger.error(message);
     process.exitCode = 1;