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

package/dist/{whoami-66YKY5DZ.js → whoami-3FRWYGML.js}

@@ -5,8 +5,8 @@ import {
 import {
   warnUnknownFlags,
   whoami
-} from "./chunk-5LQIHYFC.js";
-import "./chunk-5ZUMLCD5.js";
+} from "./chunk-5JG4QJLO.js";
+import "./chunk-5SSNE5GM.js";
 import "./chunk-XCBVSGCS.js";
 
 // src/commands/whoami.ts

package/package.json

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

package/dist/store-66NK2FTQ.js

@@ -1,443 +0,0 @@
-#!/usr/bin/env node
-import {
-  regenerateBindingsSnapshot
-} from "./chunk-H3FE6VIK.js";
-import "./chunk-EOT63RDH.js";
-import {
-  getProjectTranslator
-} from "./chunk-2CY4BMTH.js";
-import {
-  assertStoreMountable,
-  storeAdd,
-  storeBind,
-  storeCreate,
-  storeExplain,
-  storeGitRemote,
-  storeList,
-  storeRemove,
-  storeSwitchWrite
-} from "./chunk-5ZUMLCD5.js";
-import {
-  loadGlobalConfig
-} from "./chunk-XCBVSGCS.js";
-
-// src/commands/store.ts
-import { defineCommand } from "citty";
-
-// src/store/store-migrate.ts
-import { execFileSync } from "child_process";
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "fs";
-import { basename, join } from "path";
-import {
-  STORE_KNOWLEDGE_TYPE_DIRS,
-  STORE_LAYOUT,
-  STORE_PENDING_DIR,
-  buildStoreResolveInput,
-  createStoreResolver,
-  formatKnowledgeId,
-  parseKnowledgeId,
-  resolveGlobalRoot,
-  storeRelativePath
-} from "@fenglimg/fabric-shared";
-function resolveTargetStore(layer, projectRoot, globalRoot) {
-  const input = buildStoreResolveInput(projectRoot, globalRoot);
-  if (input === null) {
-    return null;
-  }
-  const scope = layer === "personal" ? "personal" : "team";
-  const { target } = createStoreResolver().resolveWriteTarget(input, scope);
-  if (target === null) {
-    return null;
-  }
-  const alias = loadGlobalConfig(globalRoot)?.stores.find((s) => s.store_uuid === target.store_uuid)?.alias ?? target.store_uuid;
-  return {
-    uuid: target.store_uuid,
-    alias,
-    dir: join(globalRoot, storeRelativePath(target.store_uuid))
-  };
-}
-function listMd(dir) {
-  if (!existsSync(dir)) {
-    return [];
-  }
-  return readdirSync(dir).filter((name) => name.endsWith(".md")).sort();
-}
-function readId(content) {
-  const match = content.match(/^id:\s*(\S+)\s*$/mu);
-  return match ? match[1] : null;
-}
-function slugSuffix(fileName, oldId) {
-  const stem = fileName.replace(/\.md$/u, "");
-  if (oldId !== null && stem.startsWith(`${oldId}--`)) {
-    return stem.slice(oldId.length);
-  }
-  return "";
-}
-function buildStoreIdIndex(storeDir) {
-  const existing = /* @__PURE__ */ new Set();
-  const maxCounter = /* @__PURE__ */ new Map();
-  for (const type of STORE_KNOWLEDGE_TYPE_DIRS) {
-    const dir = join(storeDir, STORE_LAYOUT.knowledgeDir, type);
-    for (const file of listMd(dir)) {
-      const content = readFileSync(join(dir, file), "utf8");
-      const id = readId(content) ?? file.replace(/\.md$/u, "").split("--")[0];
-      const parsed = parseKnowledgeId(id);
-      if (parsed === null) {
-        continue;
-      }
-      existing.add(id);
-      const key = id.slice(0, id.lastIndexOf("-"));
-      maxCounter.set(key, Math.max(maxCounter.get(key) ?? 0, parsed.counter));
-    }
-  }
-  return { existing, maxCounter };
-}
-function nextId(index, layer, type) {
-  const probe = formatKnowledgeId(layer, type, 1);
-  const key = probe.slice(0, probe.lastIndexOf("-"));
-  let counter = (index.maxCounter.get(key) ?? 0) + 1;
-  let id = formatKnowledgeId(layer, type, counter);
-  while (index.existing.has(id)) {
-    counter += 1;
-    id = formatKnowledgeId(layer, type, counter);
-  }
-  index.existing.add(id);
-  index.maxCounter.set(key, counter);
-  return id;
-}
-function typeDirToKnowledgeType(typeDir) {
-  return STORE_KNOWLEDGE_TYPE_DIRS.includes(typeDir) ? typeDir : null;
-}
-function migrateProjectKnowledge(projectRoot, options = {}) {
-  const dryRun = options.dryRun ?? false;
-  const globalRoot = options.globalRoot ?? resolveGlobalRoot();
-  const runGit = options.git ?? true;
-  const items = [];
-  const skips = [];
-  const remap = {};
-  const targets = {};
-  const sourceRoots = {
-    team: join(projectRoot, ".fabric", "knowledge"),
-    personal: join(globalRoot, "knowledge")
-  };
-  const layerState = {};
-  for (const layer of ["team", "personal"]) {
-    if (!existsSync(sourceRoots[layer])) {
-      continue;
-    }
-    const target = resolveTargetStore(layer, projectRoot, globalRoot);
-    if (target === null) {
-      continue;
-    }
-    targets[layer] = { uuid: target.uuid, dir: target.dir };
-    layerState[layer] = { target, index: buildStoreIdIndex(target.dir) };
-  }
-  for (const layer of ["team", "personal"]) {
-    const root = sourceRoots[layer];
-    if (!existsSync(root)) {
-      continue;
-    }
-    const state = layerState[layer];
-    for (const typeDir of STORE_KNOWLEDGE_TYPE_DIRS) {
-      const dir = join(root, typeDir);
-      for (const file of listMd(dir)) {
-        const source = join(dir, file);
-        if (state === void 0) {
-          skips.push({
-            source,
-            reason: `no ${layer} write-target store \u2014 run \`fabric install --global\` then \`fabric store bind <alias>\`${layer === "team" ? " + `fabric store switch-write <alias>`" : ""}`
-          });
-          continue;
-        }
-        const content = readFileSync(source, "utf8");
-        const oldId = readId(content);
-        const knowledgeType = typeDirToKnowledgeType(typeDir);
-        let newId = null;
-        if (oldId !== null && state.index.existing.has(oldId) && knowledgeType !== null) {
-          const parsed = parseKnowledgeId(oldId);
-          const idLayer = parsed?.layer ?? layer;
-          newId = nextId(state.index, idLayer, knowledgeType);
-          remap[oldId] = newId;
-        } else if (oldId !== null) {
-          state.index.existing.add(oldId);
-          const parsed = parseKnowledgeId(oldId);
-          if (parsed !== null) {
-            const key = oldId.slice(0, oldId.lastIndexOf("-"));
-            state.index.maxCounter.set(
-              key,
-              Math.max(state.index.maxCounter.get(key) ?? 0, parsed.counter)
-            );
-          }
-        }
-        const effectiveId = newId ?? oldId;
-        const targetName = newId !== null && effectiveId !== null ? `${effectiveId}${slugSuffix(file, oldId)}.md` : file;
-        const targetFile = join(state.target.dir, STORE_LAYOUT.knowledgeDir, typeDir, targetName);
-        items.push({
-          source,
-          layer,
-          type: typeDir,
-          oldId,
-          newId,
-          target: targetFile,
-          storeUuid: state.target.uuid,
-          alias: state.target.alias
-        });
-      }
-    }
-    const pendingRoot = join(root, STORE_PENDING_DIR);
-    for (const sub of [".", "decisions", "guidelines", "pitfalls", "models", "processes"]) {
-      const dir = sub === "." ? pendingRoot : join(pendingRoot, sub);
-      for (const file of listMd(dir)) {
-        const source = join(dir, file);
-        if (state === void 0) {
-          skips.push({ source, reason: `no ${layer} write-target store` });
-          continue;
-        }
-        const rel = sub === "." ? file : join(sub, file);
-        const targetFile = join(
-          state.target.dir,
-          STORE_LAYOUT.knowledgeDir,
-          STORE_PENDING_DIR,
-          rel
-        );
-        if (existsSync(targetFile)) {
-          skips.push({ source, reason: `pending already present in store: ${basename(targetFile)}` });
-          continue;
-        }
-        items.push({
-          source,
-          layer,
-          type: STORE_PENDING_DIR,
-          oldId: null,
-          newId: null,
-          target: targetFile,
-          storeUuid: state.target.uuid,
-          alias: state.target.alias
-        });
-      }
-    }
-  }
-  if (dryRun || items.length === 0) {
-    return { dryRun, committed: false, items, skips, remap, targets };
-  }
-  for (const item of items) {
-    let content = readFileSync(item.source, "utf8");
-    if (item.newId !== null && item.oldId !== null) {
-      content = content.replace(/^id:\s*\S+\s*$/mu, `id: ${item.newId}`);
-    }
-    content = rewriteRelated(content, remap);
-    mkdirSync(join(item.target, ".."), { recursive: true });
-    writeFileSync(item.target, content, "utf8");
-  }
-  for (const item of items) {
-    rmSync(item.source, { force: true });
-  }
-  let committed = false;
-  if (runGit) {
-    for (const [layer, info] of Object.entries(targets)) {
-      const moved = items.filter((i) => i.layer === layer).length;
-      if (moved === 0) {
-        continue;
-      }
-      committed = gitCommitStore(info.dir, moved) || committed;
-    }
-  }
-  return { dryRun, committed, items, skips, remap, targets };
-}
-function rewriteRelated(content, remap) {
-  if (Object.keys(remap).length === 0) {
-    return content;
-  }
-  return content.replace(/^related:\s*\[(.*)\]\s*$/mu, (line, inner) => {
-    const rewritten = inner.split(",").map((token) => {
-      const trimmed = token.trim();
-      return remap[trimmed] ?? trimmed;
-    }).join(", ");
-    return `related: [${rewritten}]`;
-  });
-}
-function gitCommitStore(storeDir, count) {
-  if (!existsSync(join(storeDir, ".git"))) {
-    return false;
-  }
-  try {
-    execFileSync("git", ["add", "-A"], { cwd: storeDir, stdio: ["ignore", "ignore", "pipe"] });
-    execFileSync(
-      "git",
-      ["commit", "-m", `chore(migrate): import ${count} entries from project dual-root`],
-      { cwd: storeDir, stdio: ["ignore", "ignore", "pipe"] }
-    );
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/commands/store.ts
-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) {
-      const realRemote = storeGitRemote(store.store_uuid);
-      console.log(`${store.alias}	${store.store_uuid}	${realRemote ?? 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);
-    const t = getProjectTranslator();
-    console.log(
-      t("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 migrateCommand = defineCommand({
-  meta: {
-    name: "migrate",
-    description: "Move project-local (dual-root) knowledge into the resolved write-target stores"
-  },
-  args: {
-    "dry-run": {
-      type: "boolean",
-      description: "Preview the move without writing anything"
-    }
-  },
-  run({ args }) {
-    const projectRoot = process.cwd();
-    const t = getProjectTranslator(projectRoot);
-    const dryRun = args["dry-run"] === true;
-    const report = migrateProjectKnowledge(projectRoot, { dryRun });
-    if (report.items.length === 0 && report.skips.length === 0) {
-      console.log(t("cli.store.migrate.none"));
-      return;
-    }
-    console.log(
-      dryRun ? t("cli.store.migrate.dry-run-header") : t("cli.store.migrate.applied-header", { count: String(report.items.length) })
-    );
-    for (const item of report.items) {
-      const id = item.newId ?? item.oldId ?? "(draft)";
-      console.log(`  ${item.layer}/${item.type}  ${id}  \u2192  ${item.alias}`);
-      if (item.newId !== null && item.oldId !== null) {
-        console.log(
-          t("cli.store.migrate.remap-note", { oldId: item.oldId, newId: item.newId })
-        );
-      }
-    }
-    if (report.skips.length > 0) {
-      console.log(t("cli.store.migrate.skips-header", { count: String(report.skips.length) }));
-      for (const skip of report.skips) {
-        console.log(`  ${skip.source}: ${skip.reason}`);
-      }
-    }
-    if (report.committed) {
-      console.log(t("cli.store.migrate.committed"));
-    }
-  }
-});
-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,
-    migrate: migrateCommand
-  }
-});
-export {
-  store_default as default
-};