@fenglimg/fabric-cli 2.2.0-rc.1 → 2.2.0-rc.3

package/dist/{sync-UJ4BBCZJ.js → sync-EA5HZMXM.js}

@@ -1,23 +1,22 @@
 #!/usr/bin/env node
 import {
   regenerateBindingsSnapshot
-} from "./chunk-WU6GAPKH.js";
-import "./chunk-L4Q55UC4.js";
+} from "./chunk-H3FE6VIK.js";
+import "./chunk-EOT63RDH.js";
 import {
   getProjectTranslator
 } from "./chunk-2CY4BMTH.js";
-import "./chunk-LFIKMVY7.js";
 import {
   loadGlobalConfig,
   resolveGlobalRoot
-} from "./chunk-RYAFBNES.js";
+} from "./chunk-XCBVSGCS.js";
 
 // src/commands/sync.ts
 import { defineCommand } from "citty";
 
 // src/sync/run-sync.ts
 import { execFileSync } from "child_process";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
 import { join } from "path";
 import { GLOBAL_STATE_DIR, storeRelativePath } from "@fenglimg/fabric-shared";
 import { GenericIOError } from "@fenglimg/fabric-shared/errors";
@@ -33,6 +32,7 @@ function syncTransition(state, event) {
     case "conflict":
       if (event === "user_continue") return "synced";
       if (event === "user_abort") return "aborted";
+      if (event === "network_unavailable") return "offline";
       break;
     case "offline":
       if (event === "retry" || event === "rebase_clean") return "synced";
@@ -88,13 +88,31 @@ function loadSession(globalRoot) {
   if (!existsSync(path)) {
     return null;
   }
-  return JSON.parse(readFileSync(path, "utf8"));
+  const raw = readFileSync(path, "utf8");
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    const corruptedPath = `${path}.corrupted.${Date.now()}`;
+    try {
+      writeFileSync(corruptedPath, raw, "utf8");
+    } catch {
+    }
+    throw new GenericIOError(
+      `sync-session.json is corrupt (forensic copy: ${corruptedPath}). Parse error: ${error instanceof Error ? error.message : String(error)}`,
+      {
+        actionHint: `Delete ${path} to start a fresh sync (any in-progress rebase must be resolved manually with git first).`,
+        details: { path, corruptedPath }
+      }
+    );
+  }
 }
 function saveSession(globalRoot, session) {
   const path = syncSessionPath(globalRoot);
   mkdirSync(join(path, ".."), { recursive: true });
-  writeFileSync(path, `${JSON.stringify(session, null, 2)}
+  const tmpPath = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmpPath, `${JSON.stringify(session, null, 2)}
 `, "utf8");
+  renameSync(tmpPath, path);
 }
 function clearSession(globalRoot) {
   rmSync(syncSessionPath(globalRoot), { force: true });
@@ -127,28 +145,105 @@ function gitErrText(error, key) {
   const value = error[key];
   return typeof value === "string" || Buffer.isBuffer(value) ? String(value) : "";
 }
+function defaultPush(storeDir) {
+  try {
+    execFileSync("git", ["push"], {
+      cwd: storeDir,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return "clean";
+  } catch (error) {
+    const detail = `${gitErrText(error, "stdout")}${gitErrText(error, "stderr")}`;
+    if (/could not resolve host|could not read from remote|unable to access|connection|network is unreachable|timed out/i.test(
+      detail
+    )) {
+      return "offline";
+    }
+    const gitMessage = detail.trim().length > 0 ? detail.trim() : "unknown git error";
+    throw new GenericIOError(`git push failed in ${storeDir}: ${gitMessage}`, {
+      actionHint: "resolve the git issue above (e.g. authentication, no upstream branch, or a rejected non-fast-forward push), then re-run `fabric sync`",
+      details: error
+    });
+  }
+}
+function defaultCommitDirty(storeDir) {
+  try {
+    execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+      cwd: storeDir,
+      stdio: ["ignore", "ignore", "ignore"]
+    });
+  } catch {
+    return;
+  }
+  try {
+    execFileSync("git", ["add", "-A"], { cwd: storeDir, stdio: ["ignore", "ignore", "pipe"] });
+    try {
+      execFileSync("git", ["diff", "--cached", "--quiet"], {
+        cwd: storeDir,
+        stdio: ["ignore", "ignore", "ignore"]
+      });
+      return;
+    } catch {
+      execFileSync("git", ["commit", "-m", "fabric: sync local knowledge changes"], {
+        cwd: storeDir,
+        stdio: ["ignore", "ignore", "pipe"]
+      });
+    }
+  } catch {
+  }
+}
+function runRebaseStep(storeDir, step) {
+  try {
+    execFileSync("git", ["rebase", `--${step}`], {
+      cwd: storeDir,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch (error) {
+    const detail = `${gitErrText(error, "stdout")}${gitErrText(error, "stderr")}`.trim();
+    const gitMessage = detail.length > 0 ? detail : "unknown git error";
+    throw new GenericIOError(`git rebase --${step} failed in ${storeDir}: ${gitMessage}`, {
+      actionHint: step === "continue" ? "resolve the remaining conflicts (git status) and stage them, then re-run `fabric sync --continue`; or run `fabric sync --abort` to discard the rebase" : "inspect the store with `git status`; if no rebase is in progress the session may already be resolved \u2014 delete sync-session.json to reset",
+      details: error
+    });
+  }
+}
 function defaultRebaseContinue(storeDir) {
-  execFileSync("git", ["rebase", "--continue"], { cwd: storeDir, stdio: "ignore" });
+  runRebaseStep(storeDir, "continue");
 }
 function defaultRebaseAbort(storeDir) {
-  execFileSync("git", ["rebase", "--abort"], { cwd: storeDir, stdio: "ignore" });
+  runRebaseStep(storeDir, "abort");
 }
 var OUTCOME_EVENT = {
   clean: "rebase_clean",
   conflict: "rebase_conflict",
   offline: "network_unavailable"
 };
-function walkPending(session, storeDirOf, pull) {
+function walkPending(session, storeDirOf, pull, push, commit, pushableAliases) {
   let next = session;
   for (const store of session.stores) {
     if (store.state !== "pending") {
       continue;
     }
-    const outcome = pull(storeDirOf(store));
-    next = applySyncEvent(next, store.alias, OUTCOME_EVENT[outcome]);
-    if (outcome === "conflict") {
-      break;
+    const dir = storeDirOf(store);
+    commit(dir);
+    const pullOutcome = pull(dir);
+    if (pullOutcome !== "clean") {
+      next = applySyncEvent(next, store.alias, OUTCOME_EVENT[pullOutcome]);
+      if (pullOutcome === "conflict") {
+        break;
+      }
+      continue;
     }
+    if (!pushableAliases.has(store.alias)) {
+      next = applySyncEvent(next, store.alias, "rebase_clean");
+      continue;
+    }
+    const pushOutcome = push(dir);
+    next = applySyncEvent(
+      next,
+      store.alias,
+      pushOutcome === "clean" ? "rebase_clean" : "network_unavailable"
+    );
   }
   return next;
 }
@@ -179,37 +274,86 @@ function runStartSync(options) {
     syncable.map((store) => ({ alias: store.alias, store_uuid: store.store_uuid }))
   );
   const storeDirOf = (status) => join(globalRoot, storeRelativePath(status.store_uuid));
-  const walked = walkPending(session, storeDirOf, options.pull ?? defaultPull);
+  const pushableAliases = pushableAliasesOf(config);
+  const walked = walkPending(
+    session,
+    storeDirOf,
+    options.pull ?? defaultPull,
+    options.push ?? defaultPush,
+    options.commit ?? defaultCommitDirty,
+    pushableAliases
+  );
   return finalize(walked, options, globalRoot);
 }
+function pushableAliasesOf(config) {
+  return new Set(
+    config.stores.filter((store) => store.remote !== void 0 && (store.writable ?? true)).map((store) => store.alias)
+  );
+}
 function runContinueSync(options) {
   const globalRoot = options.globalRoot ?? resolveGlobalRoot();
   const session = loadSession(globalRoot);
   if (session === null) {
-    throw new Error(NO_SESSION);
+    throw new GenericIOError(NO_SESSION, {
+      actionHint: "Run `fabric sync` to start a sync before `--continue`/`--abort`."
+    });
   }
   const conflicted = session.stores.find((store) => store.state === "conflict");
   if (conflicted === void 0) {
-    throw new Error(NO_CONFLICT);
+    throw new GenericIOError(NO_CONFLICT, {
+      actionHint: "The sync is not paused on a conflict; there is nothing to resume."
+    });
   }
   const storeDirOf = (status) => join(globalRoot, storeRelativePath(status.store_uuid));
   (options.rebaseContinue ?? defaultRebaseContinue)(storeDirOf(conflicted));
-  const resumed = walkPending(continueSync(session), storeDirOf, options.pull ?? defaultPull);
+  const pushableAliases = pushableAliasesOf(loadGlobalConfig(globalRoot) ?? { stores: [] });
+  const push = options.push ?? defaultPush;
+  let advanced;
+  if (pushableAliases.has(conflicted.alias)) {
+    const pushOutcome = push(storeDirOf(conflicted));
+    advanced = applySyncEvent(
+      session,
+      conflicted.alias,
+      pushOutcome === "clean" ? "user_continue" : "network_unavailable"
+    );
+  } else {
+    advanced = continueSync(session);
+  }
+  const resumed = walkPending(
+    advanced,
+    storeDirOf,
+    options.pull ?? defaultPull,
+    push,
+    options.commit ?? defaultCommitDirty,
+    pushableAliases
+  );
   return finalize(resumed, options, globalRoot);
 }
 function runAbortSync(options) {
   const globalRoot = options.globalRoot ?? resolveGlobalRoot();
   const session = loadSession(globalRoot);
   if (session === null) {
-    throw new Error(NO_SESSION);
+    throw new GenericIOError(NO_SESSION, {
+      actionHint: "Run `fabric sync` to start a sync before `--continue`/`--abort`."
+    });
   }
   const conflicted = session.stores.find((store) => store.state === "conflict");
   if (conflicted === void 0) {
-    throw new Error(NO_CONFLICT);
+    throw new GenericIOError(NO_CONFLICT, {
+      actionHint: "The sync is not paused on a conflict; there is nothing to resume."
+    });
   }
   const storeDirOf = (status) => join(globalRoot, storeRelativePath(status.store_uuid));
   (options.rebaseAbort ?? defaultRebaseAbort)(storeDirOf(conflicted));
-  const resumed = walkPending(abortSync(session), storeDirOf, options.pull ?? defaultPull);
+  const pushableAliases = pushableAliasesOf(loadGlobalConfig(globalRoot) ?? { stores: [] });
+  const resumed = walkPending(
+    abortSync(session),
+    storeDirOf,
+    options.pull ?? defaultPull,
+    options.push ?? defaultPush,
+    options.commit ?? defaultCommitDirty,
+    pushableAliases
+  );
   return finalize(resumed, options, globalRoot);
 }
 

package/dist/{uninstall-C3QXKOO6.js → uninstall-F75MPKQC.js}

@@ -7,7 +7,7 @@ import {
   HOOK_SCRIPT_DESTINATIONS,
   SKILL_DESTINATIONS,
   fabricAgentsSnapshotPath
-} from "./chunk-2R55HNVD.js";
+} from "./chunk-XHHCRDIR.js";
 import {
   paint
 } from "./chunk-BO4XIZWZ.js";
@@ -88,6 +88,20 @@ async function removeCitePolicyEvictHook(projectRoot) {
     projectRoot
   );
 }
+async function removeSessionEndMarkerHook(projectRoot) {
+  return removeHookScripts(
+    "hook-session-end-script",
+    HOOK_SCRIPT_DESTINATIONS.sessionEndMarker,
+    projectRoot
+  );
+}
+async function removePostTooluseMutationHook(projectRoot) {
+  return removeHookScripts(
+    "hook-post-tooluse-script",
+    HOOK_SCRIPT_DESTINATIONS.postTooluseMutation,
+    projectRoot
+  );
+}
 async function removeHookScripts(step, rels, projectRoot) {
   const results = [];
   for (const rel of rels) {
@@ -323,6 +337,18 @@ async function uninstallBootstrapStage(projectRoot, _opts = {}) {
     projectRoot,
     () => removeCitePolicyEvictHook(projectRoot)
   );
+  await runAndCollect(
+    results,
+    "hook-session-end-script",
+    projectRoot,
+    () => removeSessionEndMarkerHook(projectRoot)
+  );
+  await runAndCollect(
+    results,
+    "hook-post-tooluse-script",
+    projectRoot,
+    () => removePostTooluseMutationHook(projectRoot)
+  );
   await runAndCollect(
     results,
     "skill-connect",

package/dist/{whoami-2MLO4Y37.js → whoami-66YKY5DZ.js}

@@ -3,18 +3,29 @@ import {
   getProjectTranslator
 } from "./chunk-2CY4BMTH.js";
 import {
+  warnUnknownFlags,
   whoami
-} from "./chunk-T5RPGCCM.js";
-import "./chunk-LFIKMVY7.js";
-import "./chunk-RYAFBNES.js";
+} from "./chunk-5LQIHYFC.js";
+import "./chunk-5ZUMLCD5.js";
+import "./chunk-XCBVSGCS.js";
 
 // src/commands/whoami.ts
 import { defineCommand } from "citty";
 var whoami_default = defineCommand({
   meta: { name: "whoami", description: "Show this machine's Fabric uid and mounted stores" },
-  run() {
-    const t = getProjectTranslator();
+  args: {
+    // F27: `--json` machine-readable output (was silently ignored — the command
+    // declared no args, so citty swallowed the flag and still printed text).
+    json: { type: "boolean", description: "Emit machine-readable JSON instead of text" }
+  },
+  run({ args }) {
+    warnUnknownFlags(["json"]);
     const info = whoami();
+    if (args.json === true) {
+      console.log(JSON.stringify(info, null, 2));
+      return;
+    }
+    const t = getProjectTranslator();
     if (info === null) {
       console.log(t("cli.cmd.no-global-config"));
       return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fenglimg/fabric-cli",
-  "version": "2.2.0-rc.1",
+  "version": "2.2.0-rc.3",
   "description": "Fabric CLI — installs the MCP server + skills + hooks for Claude Code, Cursor, and Codex CLI; runs doctor / knowledge maintenance.",
   "license": "MIT",
   "author": "wangzhichao <fenglimg90@gmail.com>",
@@ -45,8 +45,8 @@
     "tree-sitter-javascript": "^0.25.0",
     "tree-sitter-typescript": "^0.23.2",
     "web-tree-sitter": "^0.26.8",
-    "@fenglimg/fabric-server": "2.2.0-rc.1",
-    "@fenglimg/fabric-shared": "2.2.0-rc.1"
+    "@fenglimg/fabric-server": "2.2.0-rc.3",
+    "@fenglimg/fabric-shared": "2.2.0-rc.3"
   },
   "devDependencies": {
     "@types/node": "^22.15.0",