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

package/dist/{metrics-ACEQFPDU.js → metrics-RER6NLFC.js}

@@ -1,14 +1,17 @@
 #!/usr/bin/env node
+import {
+  getProjectTranslator
+} from "./chunk-2CY4BMTH.js";
 
 // src/commands/metrics.ts
 import { resolve } from "path";
 import { defineCommand } from "citty";
 import { readMetrics } from "@fenglimg/fabric-server";
-function parseSinceArg(raw) {
+function parseSinceArg(raw, t) {
   if (raw === void 0 || raw.length === 0) return 0;
   const match = /^(\d+)([smhd]?)$/u.exec(raw);
   if (match === null) {
-    throw new Error(`--since: invalid duration "${raw}" (expected e.g. 24h, 7d, 30m)`);
+    throw new Error(t("cli.metrics.invalid-since", { raw }));
   }
   const n = Number.parseInt(match[1], 10);
   const unit = match[2] ?? "s";
@@ -36,6 +39,8 @@ function aggregate(rows, sinceMs, now) {
     }
   }
   return {
+    // Stable token (NOT localized) so the --json contract is locale-independent;
+    // renderText localizes "all-time" at presentation time only.
     windowDescription: sinceMs > 0 ? formatDuration(sinceMs) : "all-time",
     rowCount: filtered.length,
     totals,
@@ -50,17 +55,24 @@ function formatDuration(ms) {
   if (ms >= 6e4) return `${Math.round(ms / 6e4)}m`;
   return `${Math.round(ms / 1e3)}s`;
 }
-function renderText(agg) {
+function renderText(agg, t) {
   const lines = [];
-  lines.push(`Fabric metrics \u2014 window: ${agg.windowDescription}`);
+  const windowDisplay = agg.windowDescription === "all-time" ? t("cli.metrics.window-all-time") : agg.windowDescription;
+  lines.push(t("cli.metrics.window", { window: windowDisplay }));
   if (agg.rangeStart && agg.rangeEnd) {
-    lines.push(`  rows: ${agg.rowCount} (${agg.rangeStart} \u2192 ${agg.rangeEnd})`);
+    lines.push(
+      t("cli.metrics.rows-range", {
+        count: String(agg.rowCount),
+        start: agg.rangeStart,
+        end: agg.rangeEnd
+      })
+    );
   } else {
-    lines.push(`  rows: ${agg.rowCount}`);
+    lines.push(t("cli.metrics.rows", { count: String(agg.rowCount) }));
   }
   lines.push("");
   if (Object.keys(agg.totals).length === 0) {
-    lines.push("  (no counter activity in window \u2014 server may be idle or just started)");
+    lines.push(t("cli.metrics.no-activity"));
     return lines.join("\n");
   }
   lines.push("  counter                              total");
@@ -103,14 +115,15 @@ var metricsCommand = defineCommand({
   },
   async run({ args }) {
     const projectRoot = resolve(args.target ?? process.cwd());
-    const sinceMs = parseSinceArg(args.since);
+    const t = getProjectTranslator(projectRoot);
+    const sinceMs = parseSinceArg(args.since, t);
     const rows = await readMetrics(projectRoot);
     const aggregated = aggregate(rows, sinceMs, /* @__PURE__ */ new Date());
     if (args.json === true) {
       process.stdout.write(`${JSON.stringify(aggregated)}
 `);
     } else {
-      process.stdout.write(`${renderText(aggregated)}
+      process.stdout.write(`${renderText(aggregated, t)}
 `);
     }
   }

package/dist/{onboard-coverage-MFCAEBDO.js → onboard-coverage-JWQWDZW7.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   t
-} from "./chunk-PWLW3B57.js";
+} from "./chunk-2CY4BMTH.js";
 
 // src/commands/onboard-coverage.ts
 import { existsSync, readdirSync, readFileSync } from "fs";

package/dist/scope-explain-CDIZESP5.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import {
+  scopeExplain
+} from "./chunk-L4Q55UC4.js";
+import {
+  getProjectTranslator
+} from "./chunk-2CY4BMTH.js";
+import "./chunk-LFIKMVY7.js";
+import "./chunk-RYAFBNES.js";
+
+// src/commands/scope-explain.ts
+import { defineCommand } from "citty";
+var scope_explain_default = defineCommand({
+  meta: {
+    name: "scope-explain",
+    description: "Explain the resolved read-set and write target for a scope"
+  },
+  args: {
+    scope: {
+      type: "positional",
+      required: true,
+      description: "Scope coordinate (e.g. team, project:x, personal)"
+    }
+  },
+  run({ args }) {
+    const projectRoot = process.cwd();
+    const result = scopeExplain(projectRoot, args.scope);
+    if (result === null) {
+      console.log(getProjectTranslator(projectRoot)("cli.cmd.no-global-config"));
+      return;
+    }
+    console.log(JSON.stringify(result, null, 2));
+  }
+});
+export {
+  scope_explain_default as default
+};

package/dist/status-GLQWLWH6.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import {
+  projectStatus
+} from "./chunk-T5RPGCCM.js";
+import "./chunk-LFIKMVY7.js";
+import "./chunk-RYAFBNES.js";
+
+// src/commands/status.ts
+import { defineCommand } from "citty";
+var status_default = defineCommand({
+  meta: { name: "status", description: "Show this project's Fabric store status" },
+  run() {
+    const status = projectStatus(process.cwd());
+    console.log(`uid:            ${status.uid ?? "(no global config)"}`);
+    console.log(`project_id:     ${status.project_id ?? "(not a Fabric project)"}`);
+    console.log(`mounted stores: ${status.mounted.length > 0 ? status.mounted.join(", ") : "(none)"}`);
+    console.log(`required:       ${status.required.length > 0 ? status.required.join(", ") : "(none)"}`);
+    console.log(`active write:   ${status.active_write_store ?? "(none \u2014 personal scope only)"}`);
+  }
+});
+export {
+  status_default as default
+};

package/dist/store-XB3ADT65.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+import {
+  assertStoreMountable,
+  storeAdd,
+  storeBind,
+  storeCreate,
+  storeExplain,
+  storeList,
+  storeRemove,
+  storeSwitchWrite
+} from "./chunk-4R2CYEA4.js";
+import {
+  regenerateBindingsSnapshot
+} from "./chunk-WU6GAPKH.js";
+import "./chunk-L4Q55UC4.js";
+import {
+  getProjectTranslator
+} from "./chunk-2CY4BMTH.js";
+import "./chunk-LFIKMVY7.js";
+import "./chunk-RYAFBNES.js";
+
+// src/commands/store.ts
+import { defineCommand } from "citty";
+var listCommand = defineCommand({
+  meta: { name: "list", description: "List mounted knowledge stores" },
+  run() {
+    const t = getProjectTranslator();
+    const stores = storeList();
+    if (stores.length === 0) {
+      console.log(t("cli.store.none-mounted"));
+      return;
+    }
+    const localOnly = t("cli.shared.local-only");
+    for (const store of stores) {
+      console.log(`${store.alias}	${store.store_uuid}	${store.remote ?? localOnly}`);
+    }
+  }
+});
+var addCommand = defineCommand({
+  meta: { name: "add", description: "Mount a knowledge store into the global registry" },
+  args: {
+    uuid: { type: "string", required: true, description: "Intrinsic store UUID" },
+    alias: { type: "string", required: true, description: "Local alias for this store" },
+    remote: { type: "string", description: "Git remote locator (omit for local-only)" }
+  },
+  run({ args }) {
+    assertStoreMountable(args.uuid);
+    const store = args.remote === void 0 ? { store_uuid: args.uuid, alias: args.alias } : { store_uuid: args.uuid, alias: args.alias, remote: args.remote };
+    const next = storeAdd(store);
+    console.log(
+      getProjectTranslator()("cli.store.mounted", {
+        alias: args.alias,
+        count: String(next.stores.length)
+      })
+    );
+  }
+});
+var createCommand = defineCommand({
+  meta: { name: "create", description: "Create a brand-new local knowledge store and mount it" },
+  args: {
+    alias: { type: "string", required: true, description: "Local alias for the new store" },
+    remote: { type: "string", description: "Git remote to associate (push target; optional)" }
+  },
+  run({ args }) {
+    const result = storeCreate(args.alias, (/* @__PURE__ */ new Date()).toISOString(), {
+      ...args.remote === void 0 ? {} : { remote: args.remote }
+    });
+    const t = getProjectTranslator();
+    console.log(
+      t("cli.store.created", { alias: args.alias, uuid: result.store_uuid, dir: result.storeDir }) + (args.remote === void 0 ? `
+${t("cli.store.created-local-hint")}` : "")
+    );
+  }
+});
+var removeCommand = defineCommand({
+  meta: { name: "remove", description: "Detach a store from the registry (does NOT delete it)" },
+  args: {
+    alias: { type: "positional", required: true, description: "Alias to detach" }
+  },
+  run({ args }) {
+    const { detached } = storeRemove(args.alias);
+    const t = getProjectTranslator();
+    console.log(
+      detached === null ? t("cli.store.no-alias", { alias: args.alias }) : t("cli.store.detached", { alias: args.alias })
+    );
+  }
+});
+var explainCommand = defineCommand({
+  meta: { name: "explain", description: "Explain how a store alias resolves" },
+  args: {
+    alias: { type: "positional", required: true, description: "Alias to explain" }
+  },
+  run({ args }) {
+    const explanation = storeExplain(args.alias);
+    console.log(
+      explanation === null ? getProjectTranslator()("cli.store.no-alias", { alias: args.alias }) : JSON.stringify(explanation, null, 2)
+    );
+  }
+});
+var bindCommand = defineCommand({
+  meta: { name: "bind", description: "Declare a required store on this project's config" },
+  args: {
+    id: { type: "positional", required: true, description: "Store alias/UUID to require" },
+    remote: { type: "string", description: "Suggested remote for clone onboarding" }
+  },
+  run({ args }) {
+    const entry = args.remote === void 0 ? { id: args.id } : { id: args.id, suggested_remote: args.remote };
+    const projectRoot = process.cwd();
+    const next = storeBind(projectRoot, entry);
+    console.log(
+      getProjectTranslator(projectRoot)("cli.store.bound", {
+        id: args.id,
+        count: String(next.required_stores?.length ?? 0)
+      })
+    );
+    regenerateBindingsSnapshot(projectRoot, { now: (/* @__PURE__ */ new Date()).toISOString() });
+  }
+});
+var switchWriteCommand = defineCommand({
+  meta: { name: "switch-write", description: "Set the active write store for non-personal scopes" },
+  args: {
+    alias: { type: "positional", required: true, description: "Alias of the store to write to" }
+  },
+  run({ args }) {
+    const projectRoot = process.cwd();
+    storeSwitchWrite(projectRoot, args.alias);
+    console.log(getProjectTranslator(projectRoot)("cli.store.switch-write", { alias: args.alias }));
+  }
+});
+var store_default = defineCommand({
+  meta: { name: "store", description: "Manage mounted Fabric knowledge stores" },
+  subCommands: {
+    list: listCommand,
+    create: createCommand,
+    add: addCommand,
+    remove: removeCommand,
+    explain: explainCommand,
+    bind: bindCommand,
+    "switch-write": switchWriteCommand
+  }
+});
+export {
+  store_default as default
+};

package/dist/sync-UJ4BBCZJ.js

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+import {
+  regenerateBindingsSnapshot
+} from "./chunk-WU6GAPKH.js";
+import "./chunk-L4Q55UC4.js";
+import {
+  getProjectTranslator
+} from "./chunk-2CY4BMTH.js";
+import "./chunk-LFIKMVY7.js";
+import {
+  loadGlobalConfig,
+  resolveGlobalRoot
+} from "./chunk-RYAFBNES.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 { join } from "path";
+import { GLOBAL_STATE_DIR, storeRelativePath } from "@fenglimg/fabric-shared";
+import { GenericIOError } from "@fenglimg/fabric-shared/errors";
+
+// src/sync/state-machine.ts
+function syncTransition(state, event) {
+  switch (state) {
+    case "pending":
+      if (event === "rebase_clean") return "synced";
+      if (event === "rebase_conflict") return "conflict";
+      if (event === "network_unavailable") return "offline";
+      break;
+    case "conflict":
+      if (event === "user_continue") return "synced";
+      if (event === "user_abort") return "aborted";
+      break;
+    case "offline":
+      if (event === "retry" || event === "rebase_clean") return "synced";
+      if (event === "rebase_conflict") return "conflict";
+      if (event === "network_unavailable") return "offline";
+      break;
+    case "synced":
+    case "aborted":
+      break;
+  }
+  throw new Error(`invalid sync transition: '${state}' --${event}-->`);
+}
+function planSync(stores) {
+  return { stores: stores.map((s) => ({ ...s, state: "pending" })) };
+}
+function applySyncEvent(session, alias, event) {
+  return {
+    stores: session.stores.map(
+      (s) => s.alias === alias ? { ...s, state: syncTransition(s.state, event) } : s
+    )
+  };
+}
+function continueSync(session) {
+  const conflicted = session.stores.find((s) => s.state === "conflict");
+  if (conflicted === void 0) {
+    throw new Error("`sync --continue` with no conflicted store to resume");
+  }
+  return applySyncEvent(session, conflicted.alias, "user_continue");
+}
+function abortSync(session) {
+  const conflicted = session.stores.find((s) => s.state === "conflict");
+  if (conflicted === void 0) {
+    throw new Error("`sync --abort` with no conflicted store to abort");
+  }
+  return applySyncEvent(session, conflicted.alias, "user_abort");
+}
+function isSyncSettled(session) {
+  return session.stores.every((s) => s.state !== "pending" && s.state !== "conflict");
+}
+function deferredPushStores(session) {
+  return session.stores.filter((s) => s.state === "offline");
+}
+
+// src/sync/run-sync.ts
+var NO_GLOBAL_CONFIG = "no global Fabric config \u2014 run `fabric install --global <url>` first";
+var NO_SESSION = "no sync in progress \u2014 run `fabric sync` first";
+var NO_CONFLICT = "no conflicted store to resume \u2014 sync is not paused";
+function syncSessionPath(globalRoot) {
+  return join(globalRoot, GLOBAL_STATE_DIR, "sync-session.json");
+}
+function loadSession(globalRoot) {
+  const path = syncSessionPath(globalRoot);
+  if (!existsSync(path)) {
+    return null;
+  }
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+function saveSession(globalRoot, session) {
+  const path = syncSessionPath(globalRoot);
+  mkdirSync(join(path, ".."), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(session, null, 2)}
+`, "utf8");
+}
+function clearSession(globalRoot) {
+  rmSync(syncSessionPath(globalRoot), { force: true });
+}
+function defaultPull(storeDir) {
+  try {
+    execFileSync("git", ["pull", "--rebase"], {
+      cwd: storeDir,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return "clean";
+  } catch (error) {
+    const detail = `${gitErrText(error, "stdout")}${gitErrText(error, "stderr")}`;
+    if (/CONFLICT|could not apply|needs merge|rebase --continue/i.test(detail)) {
+      return "conflict";
+    }
+    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 pull --rebase failed in ${storeDir}: ${gitMessage}`, {
+      actionHint: "resolve the git issue above (e.g. authentication, a dirty working tree, or a detached HEAD), then re-run `fabric sync`",
+      details: error
+    });
+  }
+}
+function gitErrText(error, key) {
+  const value = error[key];
+  return typeof value === "string" || Buffer.isBuffer(value) ? String(value) : "";
+}
+function defaultRebaseContinue(storeDir) {
+  execFileSync("git", ["rebase", "--continue"], { cwd: storeDir, stdio: "ignore" });
+}
+function defaultRebaseAbort(storeDir) {
+  execFileSync("git", ["rebase", "--abort"], { cwd: storeDir, stdio: "ignore" });
+}
+var OUTCOME_EVENT = {
+  clean: "rebase_clean",
+  conflict: "rebase_conflict",
+  offline: "network_unavailable"
+};
+function walkPending(session, storeDirOf, pull) {
+  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;
+    }
+  }
+  return next;
+}
+function finalize(session, options, globalRoot) {
+  const settled = isSyncSettled(session);
+  let snapshotWritten = false;
+  if (settled) {
+    clearSession(globalRoot);
+    const snapshot = regenerateBindingsSnapshot(options.projectRoot, {
+      globalRoot,
+      now: options.now,
+      ...options.writeScope === void 0 ? {} : { writeScope: options.writeScope }
+    });
+    snapshotWritten = snapshot !== null;
+  } else {
+    saveSession(globalRoot, session);
+  }
+  return { session, settled, deferred: deferredPushStores(session), snapshotWritten };
+}
+function runStartSync(options) {
+  const globalRoot = options.globalRoot ?? resolveGlobalRoot();
+  const config = loadGlobalConfig(globalRoot);
+  if (config === null) {
+    throw new Error(NO_GLOBAL_CONFIG);
+  }
+  const syncable = config.stores.filter((store) => store.remote !== void 0);
+  const session = planSync(
+    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);
+  return finalize(walked, options, globalRoot);
+}
+function runContinueSync(options) {
+  const globalRoot = options.globalRoot ?? resolveGlobalRoot();
+  const session = loadSession(globalRoot);
+  if (session === null) {
+    throw new Error(NO_SESSION);
+  }
+  const conflicted = session.stores.find((store) => store.state === "conflict");
+  if (conflicted === void 0) {
+    throw new Error(NO_CONFLICT);
+  }
+  const storeDirOf = (status) => join(globalRoot, storeRelativePath(status.store_uuid));
+  (options.rebaseContinue ?? defaultRebaseContinue)(storeDirOf(conflicted));
+  const resumed = walkPending(continueSync(session), storeDirOf, options.pull ?? defaultPull);
+  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);
+  }
+  const conflicted = session.stores.find((store) => store.state === "conflict");
+  if (conflicted === void 0) {
+    throw new Error(NO_CONFLICT);
+  }
+  const storeDirOf = (status) => join(globalRoot, storeRelativePath(status.store_uuid));
+  (options.rebaseAbort ?? defaultRebaseAbort)(storeDirOf(conflicted));
+  const resumed = walkPending(abortSync(session), storeDirOf, options.pull ?? defaultPull);
+  return finalize(resumed, options, globalRoot);
+}
+
+// src/commands/sync.ts
+function report(result, projectRoot) {
+  const t = getProjectTranslator(projectRoot);
+  for (const store of result.session.stores) {
+    console.log(`${store.alias}	${store.state}`);
+  }
+  if (result.deferred.length > 0) {
+    console.log(t("cli.sync.deferred", { count: String(result.deferred.length) }));
+  }
+  if (!result.settled) {
+    console.log(t("cli.sync.paused"));
+  }
+}
+var sync_default = defineCommand({
+  meta: { name: "sync", description: "Pull --rebase + push every mounted store; resume conflicts" },
+  args: {
+    continue: { type: "boolean", description: "Resume after resolving a rebase conflict" },
+    abort: { type: "boolean", description: "Abort the conflicted store's rebase" }
+  },
+  run({ args }) {
+    const projectRoot = process.cwd();
+    const options = { projectRoot, now: (/* @__PURE__ */ new Date()).toISOString() };
+    if (args.continue === true) {
+      report(runContinueSync(options), projectRoot);
+      return;
+    }
+    if (args.abort === true) {
+      report(runAbortSync(options), projectRoot);
+      return;
+    }
+    report(runStartSync(options), projectRoot);
+  }
+});
+export {
+  sync_default as default
+};

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

@@ -7,21 +7,21 @@ import {
   HOOK_SCRIPT_DESTINATIONS,
   SKILL_DESTINATIONS,
   fabricAgentsSnapshotPath
-} from "./chunk-D25XJ4BC.js";
-import {
-  detectClientSupports,
-  resolveClients
-} from "./chunk-MF3OTILQ.js";
+} from "./chunk-2R55HNVD.js";
 import {
   paint
-} from "./chunk-WWNXR34K.js";
+} from "./chunk-BO4XIZWZ.js";
 import {
   createDebugLogger,
   resolveDevMode
 } from "./chunk-COI5VDFU.js";
+import {
+  detectClientSupports,
+  resolveClients
+} from "./chunk-XC5RUHLK.js";
 import {
   t
-} from "./chunk-PWLW3B57.js";
+} from "./chunk-2CY4BMTH.js";
 
 // src/commands/uninstall.ts
 import { existsSync as existsSync2, statSync } from "fs";
@@ -46,6 +46,15 @@ async function uninstallFabricReviewSkill(projectRoot) {
 async function uninstallFabricImportSkill(projectRoot) {
   return removeSkill("skill-import", SKILL_DESTINATIONS.fabricImport, projectRoot);
 }
+async function uninstallFabricSyncSkill(projectRoot) {
+  return removeSkill("skill-sync", SKILL_DESTINATIONS.fabricSync, projectRoot);
+}
+async function uninstallFabricAuditSkill(projectRoot) {
+  return removeSkill("skill-audit", SKILL_DESTINATIONS.fabricAudit, projectRoot);
+}
+async function uninstallFabricConnectSkill(projectRoot) {
+  return removeSkill("skill-connect", SKILL_DESTINATIONS.fabricConnect, projectRoot);
+}
 async function removeSkill(step, rels, projectRoot) {
   const results = [];
   for (const rel of rels) {
@@ -72,6 +81,13 @@ async function removeKnowledgeHintNarrowHook(projectRoot) {
     projectRoot
   );
 }
+async function removeCitePolicyEvictHook(projectRoot) {
+  return removeHookScripts(
+    "hook-cite-policy-evict-script",
+    HOOK_SCRIPT_DESTINATIONS.citePolicyEvict,
+    projectRoot
+  );
+}
 async function removeHookScripts(step, rels, projectRoot) {
   const results = [];
   for (const rel of rels) {
@@ -301,6 +317,30 @@ async function uninstallBootstrapStage(projectRoot, _opts = {}) {
     projectRoot,
     () => removeArchiveHintHook(projectRoot)
   );
+  await runAndCollect(
+    results,
+    "hook-cite-policy-evict-script",
+    projectRoot,
+    () => removeCitePolicyEvictHook(projectRoot)
+  );
+  await runAndCollect(
+    results,
+    "skill-connect",
+    projectRoot,
+    () => uninstallFabricConnectSkill(projectRoot)
+  );
+  await runAndCollect(
+    results,
+    "skill-audit",
+    projectRoot,
+    () => uninstallFabricAuditSkill(projectRoot)
+  );
+  await runAndCollect(
+    results,
+    "skill-sync",
+    projectRoot,
+    () => uninstallFabricSyncSkill(projectRoot)
+  );
   await runAndCollect(
     results,
     "skill-import",

package/dist/whoami-2MLO4Y37.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import {
+  getProjectTranslator
+} from "./chunk-2CY4BMTH.js";
+import {
+  whoami
+} from "./chunk-T5RPGCCM.js";
+import "./chunk-LFIKMVY7.js";
+import "./chunk-RYAFBNES.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();
+    const info = whoami();
+    if (info === null) {
+      console.log(t("cli.cmd.no-global-config"));
+      return;
+    }
+    console.log(t("cli.whoami.uid", { uid: info.uid }));
+    if (info.stores.length === 0) {
+      console.log(t("cli.whoami.stores-none"));
+      return;
+    }
+    console.log(t("cli.whoami.stores-label"));
+    const localOnly = t("cli.shared.local-only");
+    for (const store of info.stores) {
+      console.log(`  ${store.alias}	${store.store_uuid}${store.local_only ? `	${localOnly}` : ""}`);
+    }
+  }
+});
+export {
+  whoami_default as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fenglimg/fabric-cli",
-  "version": "2.0.1",
+  "version": "2.2.0-rc.1",
   "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.0.1",
-    "@fenglimg/fabric-shared": "2.0.1"
+    "@fenglimg/fabric-server": "2.2.0-rc.1",
+    "@fenglimg/fabric-shared": "2.2.0-rc.1"
   },
   "devDependencies": {
     "@types/node": "^22.15.0",