caveat-cli 0.20.2 → 0.20.3

package/README.md

@@ -146,6 +146,14 @@ are `ack <cursor>`, `resolve <fingerprint>`, `reopen <fingerprint>`, and
 boolean `true` keeps collection disabled. Runtime state lives under Caveat's
 own state directory, independently of the knowledge index and host hook files.
 
+Handled sync cancellation and remote failures retain local input and show a
+non-zero result without automatic app repair registration. Failed recovery is
+still reported. Severity uses observed impact (`warn` for a failed operation,
+`high` for an unavailable feature or failed recovery, `fatal` for confirmed data
+loss); occurrence counts do not raise it. Existing serious unresolved records
+remain unchanged until reviewed. Cause and recovery need diagnostic evidence.
+See the [reporting contract](https://github.com/kitepon/Caveat/blob/main/docs/01_plan.md#通信失敗の報告と重大度).
+
 Nothing is sent anywhere by default and the package contains no destination.
 To report to a collector you operate, also set
 `"runtimeErrorReportCredentialFile"` to the absolute path of the credential

package/dist/{chunk-JYXVT46B.js → chunk-TGIVITP4.js}

@@ -15313,6 +15313,34 @@ var SyncError = class extends Error {
   }
   code;
 };
+var SyncRemoteError = class extends Error {
+  constructor(phase, cause) {
+    super(`sync ${phase} did not complete; local entries are retained; remote result may be unknown: ${errorMessage2(cause)}`, { cause });
+    this.phase = phase;
+    this.name = "SyncRemoteError";
+  }
+  phase;
+};
+var SyncRecoveryError = class extends Error {
+  constructor(cause) {
+    super("sync recovery failed; inspect the local rebase before retrying", { cause });
+    this.name = "SyncRecoveryError";
+  }
+};
+async function remoteOperation(phase, run) {
+  try {
+    return await run();
+  } catch (cause) {
+    throw new SyncRemoteError(phase, cause);
+  }
+}
+async function activeRebase(git, ownDir) {
+  for (const name of ["rebase-merge", "rebase-apply"]) {
+    const path = (await git.raw(["rev-parse", "--git-path", name])).trim();
+    if (existsSync8(resolve(ownDir, path))) return true;
+  }
+  return false;
+}
 function normalizePath(path) {
   return normalizePathCase(resolve(path).replace(/\\/g, "/"));
 }
@@ -15359,6 +15387,9 @@ async function preflightSync(ownDir, opts = {}) {
   if (normalizePath(root) !== normalizePath(requested)) {
     throw new SyncError("EXTERNAL_TOPLEVEL", `EXTERNAL_TOPLEVEL: own directory must be the repository root: ${requested} (root: ${root})`);
   }
+  if (await activeRebase(git, requested)) {
+    throw new SyncError("REBASE_IN_PROGRESS", "a rebase is already active; inspect and finish or abort it before syncing");
+  }
   let branch;
   try {
     branch = (await git.raw(["symbolic-ref", "--short", "HEAD"])).trim();
@@ -15405,23 +15436,32 @@ async function syncOwn(opts) {
     await git.commit(`caveat sync: ${changed} changed file${changed === 1 ? "" : "s"}`);
     committed = true;
   }
-  const remoteBranch = (await git.raw(["ls-remote", "--heads", "origin", preflight.branch])).trim();
+  const remoteBranch = (await remoteOperation("inspect", () => git.raw(["ls-remote", "--heads", "origin", preflight.branch]))).trim();
   let pulled = false;
   if (remoteBranch) {
     try {
       await git.pull("origin", preflight.branch, ["--rebase"]);
       pulled = true;
     } catch (err) {
+      let rebasing;
+      try {
+        rebasing = await activeRebase(git, preflight.ownDir);
+      } catch (cause) {
+        throw new SyncRecoveryError(cause);
+      }
+      if (!rebasing) throw new SyncRemoteError("pull", err);
       try {
         await git.raw(["rebase", "--abort"]);
-      } catch {
+        if (await activeRebase(git, preflight.ownDir)) throw Error("rebase still active");
+      } catch (cause) {
+        throw new SyncRecoveryError(cause);
       }
       const detail = err instanceof Error ? err.message : String(err);
       throw new SyncError("SYNC_CONFLICT", `sync rebase failed and was aborted: ${detail}`);
     }
   }
   await reindexAndMark(opts);
-  await git.push("origin", preflight.branch, ["-u"]);
+  await remoteOperation("push", () => git.push("origin", preflight.branch, ["-u"]));
   return {
     ...preflight,
     committed,
@@ -15471,10 +15511,10 @@ function removeCanonicalScaffoldBeforeCheckout(ownDir) {
   }
 }
 async function defaultRemoteBranch(git, url) {
-  const symref = await git.raw(["ls-remote", "--symref", url, "HEAD"]);
+  const symref = await remoteOperation("inspect", () => git.raw(["ls-remote", "--symref", url, "HEAD"]));
   const match = /^ref: refs\/heads\/([^\s]+)\s+HEAD$/m.exec(symref);
   if (match) return match[1];
-  const heads = await git.raw(["ls-remote", "--heads", url]);
+  const heads = await remoteOperation("inspect", () => git.raw(["ls-remote", "--heads", url]));
   const first2 = /refs\/heads\/([^\s]+)\s*$/m.exec(heads);
   if (!first2) throw new Error(`remote has refs but no branch heads: ${url}`);
   return first2[1];
@@ -15487,7 +15527,7 @@ async function initOwnSync(opts) {
     throw new SyncError("OWN_REPO_EXISTS", `own knowledge directory is already a git repository: ${ownDir}`);
   }
   const inspector = createGit(ownDir);
-  const refs = (await inspector.raw(["ls-remote", "--heads", opts.url])).trim();
+  const refs = (await remoteOperation("inspect", () => inspector.raw(["ls-remote", "--heads", opts.url]))).trim();
   const entryCount = countMarkdownEntries(ownDir);
   if (refs && entryCount > 0) {
     throw new SyncError("BOTH_HAVE_ENTRIES", "local and remote both contain entries; resolve the ownership conflict before initializing sync");
@@ -15503,12 +15543,12 @@ async function initOwnSync(opts) {
       await git.add("-A");
       await git.commit(`caveat sync: initial import (${entryCount} entries)`);
       const branch2 = (await git.revparse(["--abbrev-ref", "HEAD"])).trim();
-      await git.push("origin", branch2, ["-u"]);
+      await remoteOperation("push", () => git.push("origin", branch2, ["-u"]));
       await reindexAndMark(opts);
       return { ownDir, branch: branch2, remoteWasEmpty: true };
     }
     const branch = await defaultRemoteBranch(git, opts.url);
-    await git.fetch("origin", branch);
+    await remoteOperation("fetch", () => git.fetch("origin", branch));
     removeCanonicalScaffoldBeforeCheckout(ownDir);
     await git.checkout(["--track", "-B", branch, `origin/${branch}`]);
     await reindexAndMark(opts);
@@ -15516,7 +15556,8 @@ async function initOwnSync(opts) {
   } catch (err) {
     try {
       rmSync4(createdGitDir, { recursive: true, force: true });
-    } catch {
+    } catch (cause) {
+      throw new SyncRecoveryError(cause);
     }
     throw err;
   }
@@ -15600,13 +15641,20 @@ function classifyOwnSyncOutcome(err, lastProbe) {
       return "skip";
     case "REMOTE_PUBLIC":
     case "SYNC_CONFLICT":
+    case "REBASE_IN_PROGRESS":
       return "fail";
     case "REMOTE_VISIBILITY_INDETERMINATE":
       return lastProbe?.kind === "indeterminate" && lastProbe.reason === PROBE_REQUEST_FAILED_REASON ? "network-skip" : "fail";
   }
 }
+function syncFailureCode(err) {
+  if (err instanceof SyncError) return err.code;
+  if (err instanceof SyncRemoteError) return `REMOTE_${err.phase.toUpperCase()}_FAILED`;
+  if (err instanceof SyncRecoveryError) return "RECOVERY_FAILED";
+  return "UNKNOWN";
+}
 function ownSyncFailureSignature(err) {
-  const code = err instanceof SyncError ? err.code : "UNKNOWN";
+  const code = syncFailureCode(err);
   return sha256(code);
 }
 function autoSyncNotification(outcome) {
@@ -15679,8 +15727,8 @@ async function runAutoSync(opts) {
         ownSyncState = { consecutiveFailureSignature: null, consecutiveFailureCount: 0 };
       } catch (err) {
         const disposition = classifyOwnSyncOutcome(err, lastProbe);
-        const code = err instanceof SyncError ? err.code : void 0;
-        own = { disposition, code };
+        const code = syncFailureCode(err);
+        own = { disposition, code: code === "UNKNOWN" ? void 0 : code };
         if (disposition === "fail") {
           const failureSignature = ownSyncFailureSignature(err);
           const consecutiveFailureCount = ownSyncState.consecutiveFailureSignature === failureSignature ? ownSyncState.consecutiveFailureCount + 1 : 1;
@@ -17111,15 +17159,25 @@ var STATE_VERSION = "1.0";
 var MAX_RECORDS = 256;
 var RETENTION_MS = 30 * 864e5;
 var definitions = {
-  "CAVEAT.DATABASE_OPEN_FAILED": { component: "database", severity: "high", template: "Caveat database open failed" },
-  "CAVEAT.INDEX_FAILED": { component: "index", severity: "high", template: "Caveat index operation failed" },
-  "CAVEAT.SYNC_FAILED": { component: "sync", severity: "high", template: "Caveat own sync failed" },
-  "CAVEAT.MCP_SERVER_FAILED": { component: "mcp", severity: "high", template: "Caveat MCP server failed" },
-  "CAVEAT.MCP_TOOL_FAILED": { component: "mcp_tool", severity: "high", template: "Caveat MCP tool handler failed" },
-  "CAVEAT.CLAUDE_HOOK_FAILED": { component: "claude_hook", severity: "high", template: "Caveat Claude hook failed" },
-  "CAVEAT.CODEX_HOOK_FAILED": { component: "codex_hook", severity: "high", template: "Caveat Codex hook failed" },
-  "CAVEAT.CURSOR_HOOK_FAILED": { component: "cursor_hook", severity: "high", template: "Caveat Cursor hook failed" }
+  "CAVEAT.DATABASE_OPEN_FAILED": { component: "database", template: "Caveat database open failed" },
+  "CAVEAT.INDEX_FAILED": { component: "index", template: "Caveat index operation failed" },
+  "CAVEAT.SYNC_FAILED": { component: "sync", template: "Caveat own sync failed" },
+  "CAVEAT.MCP_SERVER_FAILED": { component: "mcp", template: "Caveat MCP server failed" },
+  "CAVEAT.MCP_TOOL_FAILED": { component: "mcp_tool", template: "Caveat MCP tool handler failed" },
+  "CAVEAT.CLAUDE_HOOK_FAILED": { component: "claude_hook", template: "Caveat Claude hook failed" },
+  "CAVEAT.CODEX_HOOK_FAILED": { component: "codex_hook", template: "Caveat Codex hook failed" },
+  "CAVEAT.CURSOR_HOOK_FAILED": { component: "cursor_hook", template: "Caveat Cursor hook failed" }
 };
+function runtimeErrorSeverity(impact) {
+  if (impact === "data_lost") return "fatal";
+  if (impact === "operation_failed") return "warn";
+  if (impact === void 0 || impact === "feature_unavailable" || impact === "recovery_failed" || impact === "mutation_outcome_unverified") return "high";
+  throw Error("invalid_runtime_impact");
+}
+function highestSeverity(previous, current) {
+  const rank = ["info", "warn", "high", "fatal"];
+  return rank.indexOf(previous) >= rank.indexOf(current) ? previous : current;
+}
 function normalizeOptions(options2 = {}) {
   return "env" in options2 || "configPath" in options2 || "storePath" in options2 || "version" in options2 || "isWindows" in options2 ? options2 : { env: options2 };
 }
@@ -17194,7 +17252,7 @@ function validate(store) {
     if (!plain(record) || !exact(record, ["product", "product_version", "component", "error_code", "message_template", "severity", "fingerprint", "count", "first_seen", "last_seen", "state_schema_version", "os", "arch", "status", "resolved_at", "reason_code", "sequence"])) throw Error("state_invalid");
     const code = typeof record.error_code === "string" ? record.error_code : void 0;
     const d = code && definitions[code];
-    if (!d || record.product !== "caveat" || !validVersion(record.product_version) || record.component !== d.component || record.message_template !== d.template || record.severity !== d.severity || record.fingerprint !== fingerprint(code) || seen.has(record.fingerprint) || !Number.isSafeInteger(record.count) || record.count < 1 || !validTime(record.first_seen) || !validTime(record.last_seen) || Date.parse(record.first_seen) > Date.parse(record.last_seen) || record.state_schema_version !== STATE_VERSION || !validOs(record.os) || !validArch(record.arch) || !Number.isSafeInteger(record.sequence) || record.sequence <= previous || record.sequence >= checked.next_sequence || !["open", "resolved"].includes(record.status) || record.status === "open" && (record.resolved_at !== null || record.reason_code !== null) || record.status === "resolved" && (typeof record.resolved_at !== "string" || !validTime(record.resolved_at) || Date.parse(record.resolved_at) < Date.parse(record.last_seen) || record.reason_code !== "operator_resolved")) throw Error("state_invalid");
+    if (!d || record.product !== "caveat" || !validVersion(record.product_version) || record.component !== d.component || record.message_template !== d.template || !["fatal", "high", "warn", "info"].includes(record.severity) || record.fingerprint !== fingerprint(code) || seen.has(record.fingerprint) || !Number.isSafeInteger(record.count) || record.count < 1 || !validTime(record.first_seen) || !validTime(record.last_seen) || Date.parse(record.first_seen) > Date.parse(record.last_seen) || record.state_schema_version !== STATE_VERSION || !validOs(record.os) || !validArch(record.arch) || !Number.isSafeInteger(record.sequence) || record.sequence <= previous || record.sequence >= checked.next_sequence || !["open", "resolved"].includes(record.status) || record.status === "open" && (record.resolved_at !== null || record.reason_code !== null) || record.status === "resolved" && (typeof record.resolved_at !== "string" || !validTime(record.resolved_at) || Date.parse(record.resolved_at) < Date.parse(record.last_seen) || record.reason_code !== "operator_resolved")) throw Error("state_invalid");
     seen.add(record.fingerprint);
     previous = record.sequence;
   }
@@ -17302,6 +17360,7 @@ function recordRuntimeError(code, options2 = {}) {
     const definition = definitions[code];
     if (!definition) throw Error("unknown_runtime_code");
     const key = fingerprint(code);
+    const severity = runtimeErrorSeverity(options2.impact);
     const sequence = store.next_sequence++;
     const time = now(options2);
     const existing = store.records.find((r2) => r2.fingerprint === key);
@@ -17314,6 +17373,7 @@ function recordRuntimeError(code, options2 = {}) {
       existing.os = os;
       existing.arch = arch;
       existing.count += 1;
+      existing.severity = existing.status === "resolved" ? severity : highestSeverity(existing.severity, severity);
       existing.last_seen = time;
       existing.sequence = sequence;
       existing.status = "open";
@@ -17321,7 +17381,7 @@ function recordRuntimeError(code, options2 = {}) {
       existing.reason_code = null;
     } else {
       if (store.records.length >= MAX_RECORDS) throw Error("store_overflow");
-      store.records.push({ product: "caveat", product_version: version, component: definition.component, error_code: code, message_template: definition.template, severity: definition.severity, fingerprint: key, count: 1, first_seen: time, last_seen: time, state_schema_version: STATE_VERSION, os, arch, status: "open", resolved_at: null, reason_code: null, sequence });
+      store.records.push({ product: "caveat", product_version: version, component: definition.component, error_code: code, message_template: definition.template, severity, fingerprint: key, count: 1, first_seen: time, last_seen: time, state_schema_version: STATE_VERSION, os, arch, status: "open", resolved_at: null, reason_code: null, sequence });
     }
     store.records.sort((a, b2) => a.sequence - b2.sequence);
     writeStore(path, store, isWin, options2);
@@ -18147,6 +18207,9 @@ export {
   peekPendingRemindersDetailed,
   acknowledgePendingReminders,
   createKeyserverKeyProvider,
+  SyncError,
+  SyncRemoteError,
+  SyncRecoveryError,
   syncOwn,
   KNOWLEDGE_GITIGNORE,
   initOwnSync,
@@ -18220,4 +18283,4 @@ strip-bom-string/index.js:
 js-yaml/dist/js-yaml.mjs:
   (*! js-yaml 4.1.1 https://github.com/nodeca/js-yaml @license MIT *)
 */
-//# sourceMappingURL=chunk-JYXVT46B.js.map
+//# sourceMappingURL=chunk-TGIVITP4.js.map