@fenglimg/fabric-cli 2.1.0-rc.2 → 2.2.0-rc.3

package/dist/{chunk-PWLW3B57.js → chunk-2CY4BMTH.js}

@@ -8,11 +8,15 @@ import {
 } from "@fenglimg/fabric-shared";
 var locale = detectNodeLocale();
 var t = createTranslator(locale);
-function getDoctorTranslator(projectRoot) {
+function getProjectTranslator(projectRoot = process.cwd()) {
   return createTranslator(resolveFabricLocale(projectRoot));
 }
+function getDoctorTranslator(projectRoot) {
+  return getProjectTranslator(projectRoot);
+}
 
 export {
   t,
+  getProjectTranslator,
   getDoctorTranslator
 };

package/dist/chunk-5LQIHYFC.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import {
+  storeGitRemote
+} from "./chunk-5ZUMLCD5.js";
+import {
+  loadGlobalConfig,
+  loadProjectConfig,
+  resolveGlobalRoot
+} from "./chunk-XCBVSGCS.js";
+
+// src/lib/unknown-flags.ts
+function warnUnknownFlags(known) {
+  const knownSet = /* @__PURE__ */ new Set([...known, "help", "version"]);
+  const unknown = [];
+  for (const tok of process.argv.slice(2)) {
+    if (!tok.startsWith("--")) continue;
+    const name = tok.slice(2).split("=")[0].replace(/^no-/, "");
+    if (name.length === 0) continue;
+    if (!knownSet.has(name)) unknown.push(tok.split("=")[0]);
+  }
+  if (unknown.length > 0) {
+    process.stderr.write(`[fabric] ignored unknown flag(s): ${unknown.join(", ")}
+`);
+  }
+}
+
+// src/store/info-ops.ts
+function whoami(globalRoot = resolveGlobalRoot()) {
+  const config = loadGlobalConfig(globalRoot);
+  if (config === null) {
+    return null;
+  }
+  return {
+    uid: config.uid,
+    stores: config.stores.map((s) => ({
+      alias: s.alias,
+      store_uuid: s.store_uuid,
+      // F4: parity with `fabric store list` — local-only reflects the store
+      // repo's TRUE git remote (what sync actually pushes to), not the registry
+      // metadata. A store with a physical `origin` but no registry `remote`
+      // (e.g. the personal store) was misreported as local-only by whoami while
+      // `store list` honestly showed its remote. Both now read the same source.
+      local_only: storeGitRemote(s.store_uuid, globalRoot) === void 0
+    }))
+  };
+}
+function projectStatus(projectRoot, globalRoot = resolveGlobalRoot()) {
+  const global = loadGlobalConfig(globalRoot);
+  const project = loadProjectConfig(projectRoot);
+  return {
+    uid: global?.uid ?? null,
+    mounted: (global?.stores ?? []).map((s) => s.alias),
+    project_id: project?.project_id ?? null,
+    is_fabric_project: project !== null,
+    required: (project?.required_stores ?? []).map((r) => r.id),
+    active_write_store: project?.active_write_store ?? null
+  };
+}
+
+export {
+  warnUnknownFlags,
+  whoami,
+  projectStatus
+};

package/dist/chunk-5ZUMLCD5.js

@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+import {
+  loadGlobalConfig,
+  loadProjectConfig,
+  resolveGlobalRoot,
+  saveGlobalConfig,
+  saveProjectConfig
+} from "./chunk-XCBVSGCS.js";
+
+// src/store/store-ops.ts
+import { execFileSync } from "child_process";
+import { randomUUID } from "crypto";
+import { existsSync, lstatSync, mkdirSync, readdirSync, readlinkSync, rmSync, symlinkSync } from "fs";
+import { join } from "path";
+import {
+  addMountedStore,
+  bindRequiredStore,
+  detachMountedStore,
+  explainStore,
+  initStore,
+  STORES_ROOT_DIR,
+  storeRelativePath
+} from "@fenglimg/fabric-shared";
+var NO_GLOBAL_CONFIG = "no global Fabric config found \u2014 run `fabric install --global <url>` first";
+function requireConfig(globalRoot) {
+  const config = loadGlobalConfig(globalRoot);
+  if (config === null) {
+    throw new Error(NO_GLOBAL_CONFIG);
+  }
+  return config;
+}
+function storeList(globalRoot = resolveGlobalRoot()) {
+  return requireConfig(globalRoot).stores;
+}
+var STORE_BY_ALIAS_DIR = "by-alias";
+function syncStoreAliasLinks(globalRoot = resolveGlobalRoot()) {
+  const result = { created: [], removed: [], errors: [] };
+  const config = loadGlobalConfig(globalRoot);
+  if (config === null) {
+    return result;
+  }
+  const byAliasDir = join(globalRoot, STORES_ROOT_DIR, STORE_BY_ALIAS_DIR);
+  const desired = new Map(config.stores.map((s) => [s.alias, s.store_uuid]));
+  try {
+    mkdirSync(byAliasDir, { recursive: true });
+  } catch {
+    return result;
+  }
+  let existing = [];
+  try {
+    existing = readdirSync(byAliasDir);
+  } catch {
+    existing = [];
+  }
+  for (const name of existing) {
+    if (desired.has(name)) {
+      continue;
+    }
+    try {
+      rmSync(join(byAliasDir, name), { force: true, recursive: false });
+      result.removed.push(name);
+    } catch {
+      result.errors.push(name);
+    }
+  }
+  for (const [alias, uuid] of desired) {
+    const link = join(byAliasDir, alias);
+    const target = join("..", uuid);
+    try {
+      let current = null;
+      try {
+        if (lstatSync(link).isSymbolicLink()) {
+          current = readlinkSync(link);
+        }
+      } catch {
+        current = null;
+      }
+      if (current === target) {
+        continue;
+      }
+      rmSync(link, { force: true });
+      symlinkSync(target, link);
+      result.created.push(alias);
+    } catch {
+      result.errors.push(alias);
+    }
+  }
+  return result;
+}
+function detectAliasLinkDrift(globalRoot = resolveGlobalRoot()) {
+  const config = loadGlobalConfig(globalRoot);
+  if (config === null) {
+    return [];
+  }
+  const byAliasDir = join(globalRoot, STORES_ROOT_DIR, STORE_BY_ALIAS_DIR);
+  if (!existsSync(byAliasDir)) {
+    return [];
+  }
+  const drifted = [];
+  for (const store of config.stores) {
+    const link = join(byAliasDir, store.alias);
+    const target = join("..", store.store_uuid);
+    try {
+      if (!lstatSync(link).isSymbolicLink() || readlinkSync(link) !== target) {
+        drifted.push(store.alias);
+      }
+    } catch {
+      drifted.push(store.alias);
+    }
+  }
+  return drifted;
+}
+function storeAdd(store, globalRoot = resolveGlobalRoot()) {
+  const next = addMountedStore(requireConfig(globalRoot), store);
+  saveGlobalConfig(next, globalRoot);
+  syncStoreAliasLinks(globalRoot);
+  return next;
+}
+function storeCreate(alias, now, options = {}) {
+  const globalRoot = options.globalRoot ?? resolveGlobalRoot();
+  const config = requireConfig(globalRoot);
+  const uuid = options.uuid ?? randomUUID();
+  const storeDir = join(globalRoot, storeRelativePath(uuid));
+  initStore(
+    storeDir,
+    { store_uuid: uuid, created_at: now, canonical_alias: alias },
+    { git: options.git }
+  );
+  if (options.remote !== void 0 && options.git !== false) {
+    gitRemoteAdd(storeDir, options.remote);
+  }
+  const mounted = options.remote === void 0 ? { store_uuid: uuid, alias } : { store_uuid: uuid, alias, remote: options.remote };
+  const next = addMountedStore(config, mounted);
+  saveGlobalConfig(next, globalRoot);
+  syncStoreAliasLinks(globalRoot);
+  return { config: next, store_uuid: uuid, storeDir };
+}
+function gitRemoteAdd(storeDir, remote) {
+  try {
+    execFileSync("git", ["remote", "add", "origin", remote], {
+      cwd: storeDir,
+      stdio: ["ignore", "ignore", "pipe"]
+    });
+  } catch {
+    try {
+      execFileSync("git", ["remote", "set-url", "origin", remote], {
+        cwd: storeDir,
+        stdio: ["ignore", "ignore", "pipe"]
+      });
+    } catch {
+    }
+  }
+}
+function storeGitRemote(uuid, globalRoot = resolveGlobalRoot()) {
+  const storeDir = join(globalRoot, storeRelativePath(uuid));
+  if (!existsSync(storeDir)) {
+    return void 0;
+  }
+  try {
+    const out = execFileSync("git", ["remote", "get-url", "origin"], {
+      cwd: storeDir,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf8"
+    });
+    const trimmed = out.trim();
+    return trimmed.length > 0 ? trimmed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function assertStoreMountable(uuid, globalRoot = resolveGlobalRoot()) {
+  const storeDir = join(globalRoot, storeRelativePath(uuid));
+  if (!existsSync(join(storeDir, "store.json"))) {
+    throw new Error(
+      `cannot mount store ${uuid}: no store tree at ${storeDir} \u2014 clone it first (\`fabric install --global --url <remote>\`) or create it locally, then re-run \`fabric store add\`. Refusing to register a phantom store.`
+    );
+  }
+}
+function storeRemove(alias, globalRoot = resolveGlobalRoot()) {
+  const result = detachMountedStore(requireConfig(globalRoot), alias);
+  saveGlobalConfig(result.config, globalRoot);
+  syncStoreAliasLinks(globalRoot);
+  return result;
+}
+function storeExplain(alias, globalRoot = resolveGlobalRoot()) {
+  return explainStore(requireConfig(globalRoot), alias);
+}
+var NO_PROJECT_CONFIG = "no project Fabric config \u2014 run `fabric install` in this repo first";
+function requireProjectConfig(projectRoot) {
+  const config = loadProjectConfig(projectRoot);
+  if (config === null) {
+    throw new Error(NO_PROJECT_CONFIG);
+  }
+  return config;
+}
+function storeBind(projectRoot, entry) {
+  const config = requireProjectConfig(projectRoot);
+  const next = {
+    ...config,
+    required_stores: bindRequiredStore(config.required_stores ?? [], entry)
+  };
+  saveProjectConfig(next, projectRoot);
+  return next;
+}
+function storeSwitchWrite(projectRoot, alias) {
+  const config = requireProjectConfig(projectRoot);
+  const next = { ...config, active_write_store: alias };
+  saveProjectConfig(next, projectRoot);
+  return next;
+}
+function missingRequiredStores(projectRoot, globalRoot = resolveGlobalRoot()) {
+  const project = loadProjectConfig(projectRoot);
+  if (project === null || project.required_stores === void 0) {
+    return [];
+  }
+  const global = loadGlobalConfig(globalRoot);
+  const mounted = new Set(
+    (global?.stores ?? []).flatMap((s) => [s.alias, s.store_uuid])
+  );
+  return project.required_stores.filter((r) => !mounted.has(r.id));
+}
+function unboundAvailableStores(projectRoot, globalRoot = resolveGlobalRoot()) {
+  const global = loadGlobalConfig(globalRoot);
+  if (global === null) {
+    return [];
+  }
+  const project = loadProjectConfig(projectRoot);
+  const declared = new Set((project?.required_stores ?? []).map((r) => r.id));
+  return global.stores.filter(
+    (s) => s.personal !== true && !declared.has(s.alias) && !declared.has(s.store_uuid)
+  );
+}
+
+export {
+  storeList,
+  syncStoreAliasLinks,
+  detectAliasLinkDrift,
+  storeAdd,
+  storeCreate,
+  storeGitRemote,
+  assertStoreMountable,
+  storeRemove,
+  storeExplain,
+  storeBind,
+  storeSwitchWrite,
+  missingRequiredStores,
+  unboundAvailableStores
+};

package/dist/{chunk-WWNXR34K.js → chunk-BO4XIZWZ.js}

@@ -4,7 +4,14 @@
 import pc from "picocolors";
 import stringWidth from "string-width";
 function isColorEnabled() {
-  return !process.env.NO_COLOR && Boolean(process.stdout.isTTY) && Boolean(process.stderr.isTTY);
+  if (process.env.NO_COLOR) {
+    return false;
+  }
+  const force = process.env.FORCE_COLOR;
+  if (force !== void 0) {
+    return force !== "0" && force.toLowerCase() !== "false";
+  }
+  return Boolean(process.stdout.isTTY) && Boolean(process.stderr.isTTY);
 }
 function colorize(painter) {
   return (value) => isColorEnabled() ? painter(value) : value;

package/dist/chunk-EOT63RDH.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+// src/store/scope-explain.ts
+import {
+  SCOPE_COORDINATE_PATTERN,
+  buildStoreResolveInput,
+  createStoreResolver,
+  resolveGlobalRoot
+} from "@fenglimg/fabric-shared";
+import { GenericConfigError } from "@fenglimg/fabric-shared/errors";
+function buildResolveInput(projectRoot, globalRoot = resolveGlobalRoot()) {
+  return buildStoreResolveInput(projectRoot, globalRoot);
+}
+function scopeExplain(projectRoot, scope, globalRoot = resolveGlobalRoot()) {
+  if (!SCOPE_COORDINATE_PATTERN.test(scope)) {
+    throw new GenericConfigError(`invalid scope coordinate '${scope}'`, {
+      actionHint: "use ':'-joined lowercase [a-z0-9_-] segments, e.g. `team`, `personal`, `project:fabric-v2`, `org:acme:team:platform`",
+      details: { scope }
+    });
+  }
+  const input = buildResolveInput(projectRoot, globalRoot);
+  if (input === null) {
+    return null;
+  }
+  const resolver = createStoreResolver();
+  return {
+    scope,
+    readSet: resolver.resolveReadSet(input),
+    writeTarget: resolver.resolveWriteTarget(input, scope).target
+  };
+}
+
+export {
+  buildResolveInput,
+  scopeExplain
+};

package/dist/{chunk-BATF4PEJ.js → chunk-F6ITRM7T.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   resolveClients
-} from "./chunk-MF3OTILQ.js";
+} from "./chunk-XC5RUHLK.js";
 import {
   t
-} from "./chunk-PWLW3B57.js";
+} from "./chunk-2CY4BMTH.js";
 
 // src/commands/config.ts
 import { existsSync, statSync } from "fs";
@@ -178,8 +178,8 @@ var configCmd = defineCommand({
     "onboard-reset": onboardResetCmd
   },
   async run({ args }) {
-    const argvSub = process.argv[3];
-    if (argvSub === "dismiss-slot" || argvSub === "onboard-reset") {
+    const argvAfterConfig = process.argv.slice(3);
+    if (argvAfterConfig.includes("dismiss-slot") || argvAfterConfig.includes("onboard-reset")) {
       return;
     }
     const workspaceRoot = resolve(args.target ?? process.cwd());

package/dist/{chunk-WU6GAPKH.js → chunk-H3FE6VIK.js}

@@ -1,13 +1,11 @@
 #!/usr/bin/env node
 import {
   buildResolveInput
-} from "./chunk-L4Q55UC4.js";
-import {
-  loadProjectConfig
-} from "./chunk-LFIKMVY7.js";
+} from "./chunk-EOT63RDH.js";
 import {
+  loadProjectConfig,
   resolveGlobalRoot
-} from "./chunk-RYAFBNES.js";
+} from "./chunk-XCBVSGCS.js";
 
 // src/store/bindings-io.ts
 import { writeBindingsSnapshot } from "@fenglimg/fabric-shared";

package/dist/{chunk-MF3OTILQ.js → chunk-XC5RUHLK.js}

@@ -307,7 +307,7 @@ function serializeTomlInlineTable(values) {
   const entries = Object.entries(values).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${key} = ${escapeTomlString(value)}`);
   return `{ ${entries.join(", ")} }`;
 }
-function serializeCodexServerBlock(serverName, serverEntry) {
+function serializeCodexServerBlock(serverName, serverEntry, preservedUserLines = []) {
   const lines = [
     `[mcp_servers.${serverName}]`,
     `command = ${escapeTomlString(serverEntry.command)}`,
@@ -316,9 +316,26 @@ function serializeCodexServerBlock(serverName, serverEntry) {
   if (serverEntry.env !== void 0 && Object.keys(serverEntry.env).length > 0) {
     lines.push(`env = ${serializeTomlInlineTable(serverEntry.env)}`);
   }
+  lines.push(...preservedUserLines);
   return `${lines.join("\n")}
 `;
 }
+var CODEX_MANAGED_BLOCK_KEYS = /* @__PURE__ */ new Set(["command", "args", "env"]);
+function extractCodexBlockUserLines(blockText) {
+  const out = [];
+  const lines = blockText.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+    if (/^\[/.test(trimmed)) continue;
+    const keyMatch = /^([A-Za-z0-9_-]+)\s*=/.exec(trimmed);
+    if (keyMatch !== null && CODEX_MANAGED_BLOCK_KEYS.has(keyMatch[1])) {
+      continue;
+    }
+    out.push(trimmed);
+  }
+  return out;
+}
 function trimTrailingBlankLines(value) {
   return value.replace(/\s+$/u, "");
 }
@@ -341,13 +358,16 @@ function removeCodexServerBlock(rawConfig, serverName) {
   return { text, changed };
 }
 function upsertCodexServerBlock(rawConfig, serverName, serverEntry) {
-  const block = serializeCodexServerBlock(serverName, serverEntry);
   const normalized = rawConfig.replace(/\r\n/g, "\n");
-  const legacyPattern = new RegExp(String.raw`\n?\[mcp\.servers\.${serverName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\]\n[\s\S]*?(?=\n\[[^\n]+\]\n|$)`, "g");
+  const escaped = serverName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const legacyPattern = new RegExp(String.raw`\n?\[mcp\.servers\.${escaped}\]\n[\s\S]*?(?=\n\[[^\n]+\]\n|$)`, "g");
   const currentPattern = new RegExp(
-    String.raw`\n?\[mcp_servers\.${serverName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\]\n[\s\S]*?(?=\n\[[^\n]+\]\n|$)`,
+    String.raw`\n?\[mcp_servers\.${escaped}\]\n[\s\S]*?(?=\n\[[^\n]+\]\n|$)`,
     "g"
   );
+  const existingMatch = normalized.match(currentPattern);
+  const preservedUserLines = existingMatch !== null && existingMatch.length > 0 ? extractCodexBlockUserLines(existingMatch[0]) : [];
+  const block = serializeCodexServerBlock(serverName, serverEntry, preservedUserLines);
   const withoutLegacy = normalized.replace(legacyPattern, "");
   const withoutExisting = withoutLegacy.replace(currentPattern, "");
   const trimmed = trimTrailingBlankLines(withoutExisting);
@@ -528,10 +548,11 @@ function detectClientSupports(workspaceRoot, fabricConfig = {}) {
       },
       installedCapabilities: {
         hook: existsSync4(join4(workspaceRoot, ".codex", "hooks.json")),
-        // v2/rc.2: v1 client-side init skill removed; skill-installation probes
-        // will return once rc.2/3/4 introduce the v2 skills (fabric-archive,
-        // fabric-review, fabric-import). Until then there is nothing to probe.
-        skill: false
+        // F6: the v2 skills (fabric-archive/review/import/…) DO install to
+        // `.codex/skills/` now, so probe that directory instead of the stale
+        // hardcoded `false` (which made `fabric install` always re-report Codex
+        // skills as uninstalled even right after installing them).
+        skill: existsSync4(join4(workspaceRoot, ".codex", "skills"))
       }
     }
   ];

package/dist/chunk-XCBVSGCS.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+// src/store/global-config-io.ts
+import {
+  resolveGlobalRoot,
+  globalConfigPath,
+  loadGlobalConfig,
+  saveGlobalConfig
+} from "@fenglimg/fabric-shared";
+
+// src/store/project-config-io.ts
+import {
+  projectConfigPath,
+  loadProjectConfig,
+  saveProjectConfig
+} from "@fenglimg/fabric-shared";
+
+export {
+  resolveGlobalRoot,
+  globalConfigPath,
+  loadGlobalConfig,
+  saveGlobalConfig,
+  loadProjectConfig,
+  saveProjectConfig
+};