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

package/dist/store-ZEZMQVG7.js

@@ -0,0 +1,817 @@
+#!/usr/bin/env node
+import {
+  regenerateBindingsSnapshot
+} from "./chunk-H3FE6VIK.js";
+import "./chunk-EOT63RDH.js";
+import {
+  getProjectTranslator
+} from "./chunk-2CY4BMTH.js";
+import {
+  assertStoreMountable,
+  resolveStoreDir,
+  storeAdd,
+  storeBind,
+  storeCreate,
+  storeExplain,
+  storeGitRemote,
+  storeList,
+  storeProjectCreate,
+  storeProjectList,
+  storeRemove,
+  storeSwitchWrite
+} from "./chunk-5SSNE5GM.js";
+import {
+  loadGlobalConfig,
+  loadProjectConfig
+} from "./chunk-XCBVSGCS.js";
+
+// src/commands/store.ts
+import { defineCommand } from "citty";
+import { join as join4 } from "path";
+
+// src/store/scope-backfill.ts
+import { existsSync, readFileSync, readdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import {
+  STORE_KNOWLEDGE_TYPE_DIRS,
+  isPersonalScope,
+  parseKnowledgeId
+} from "@fenglimg/fabric-shared";
+var FRONTMATTER_RE = /^(?:)?---\r?\n([\s\S]*?)\r?\n---/u;
+function readKey(block, key) {
+  const m = new RegExp(`^${key}:\\s*"?([^"\\n]+?)"?\\s*$`, "mu").exec(block);
+  return m?.[1];
+}
+function setKey(block, key, value, anchorKey) {
+  const lines = block.split(/\r?\n/u);
+  const idx = lines.findIndex((l) => new RegExp(`^${key}:`).test(l));
+  if (idx !== -1) {
+    lines[idx] = `${key}: ${value}`;
+    return lines.join("\n");
+  }
+  const anchorIdx = lines.findIndex((l) => new RegExp(`^${anchorKey}:`).test(l));
+  const at = anchorIdx === -1 ? lines.length - 1 : anchorIdx + 1;
+  lines.splice(at, 0, `${key}: ${value}`);
+  return lines.join("\n");
+}
+function backfillEntryContent(content, visibilityStore) {
+  const match = FRONTMATTER_RE.exec(content);
+  if (match === null) {
+    return null;
+  }
+  const block = match[1] ?? "";
+  const id = readKey(block, "id") ?? null;
+  const parsed = id === null ? null : parseKnowledgeId(id);
+  const declaredLayer = readKey(block, "layer");
+  const layer = parsed?.layer ?? (declaredLayer === "personal" ? "personal" : "team");
+  const semanticScope = layer === "personal" ? "personal" : "team";
+  const visibility = isPersonalScope(semanticScope) ? "personal" : visibilityStore;
+  const changed = [];
+  let newBlock = block;
+  if (declaredLayer !== layer) {
+    newBlock = setKey(newBlock, "layer", layer, "maturity");
+    changed.push("layer");
+  }
+  if (readKey(block, "semantic_scope") !== semanticScope) {
+    newBlock = setKey(newBlock, "semantic_scope", semanticScope, "layer");
+    changed.push("semantic_scope");
+  }
+  if (readKey(block, "visibility_store") !== visibility) {
+    newBlock = setKey(newBlock, "visibility_store", `"${visibility}"`, "semantic_scope");
+    changed.push("visibility_store");
+  }
+  if (changed.length === 0) {
+    return { content, change: { file: "", id, changed } };
+  }
+  const before = content.slice(0, match.index);
+  const after = content.slice(match.index + match[0].length);
+  return {
+    content: `${before}---
+${newBlock}
+---${after}`,
+    change: { file: "", id, changed }
+  };
+}
+function backfillKnowledgeDir(knowledgeDir, options) {
+  const report = { dryRun: options.dryRun === true, unchanged: 0, changes: [], skipped: [] };
+  for (const type of STORE_KNOWLEDGE_TYPE_DIRS) {
+    const dir = join(knowledgeDir, type);
+    if (!existsSync(dir)) {
+      continue;
+    }
+    for (const name of readdirSync(dir).filter((n) => n.endsWith(".md")).sort()) {
+      const file = join(dir, name);
+      const result = backfillEntryContent(readFileSync(file, "utf8"), options.visibilityStore);
+      if (result === null) {
+        report.skipped.push(file);
+        continue;
+      }
+      if (result.change.changed.length === 0) {
+        report.unchanged += 1;
+        continue;
+      }
+      result.change.file = file;
+      report.changes.push(result.change);
+      if (options.dryRun !== true) {
+        writeFileSync(file, result.content, "utf8");
+      }
+    }
+  }
+  return report;
+}
+
+// src/store/store-migrate.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, readdirSync as readdirSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { basename, join as join2 } from "path";
+import {
+  STORE_KNOWLEDGE_TYPE_DIRS as STORE_KNOWLEDGE_TYPE_DIRS2,
+  STORE_LAYOUT,
+  STORE_PENDING_DIR,
+  buildStoreResolveInput,
+  createStoreResolver,
+  formatKnowledgeId,
+  parseKnowledgeId as parseKnowledgeId2,
+  reconcileStoreCounters,
+  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: join2(globalRoot, storeRelativePath(target.store_uuid))
+  };
+}
+function listMd(dir) {
+  if (!existsSync2(dir)) {
+    return [];
+  }
+  return readdirSync2(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_DIRS2) {
+    const dir = join2(storeDir, STORE_LAYOUT.knowledgeDir, type);
+    for (const file of listMd(dir)) {
+      const content = readFileSync2(join2(dir, file), "utf8");
+      const id = readId(content) ?? file.replace(/\.md$/u, "").split("--")[0];
+      const parsed = parseKnowledgeId2(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_DIRS2.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: join2(projectRoot, ".fabric", "knowledge"),
+    personal: join2(globalRoot, "knowledge")
+  };
+  const layerState = {};
+  for (const layer of ["team", "personal"]) {
+    if (!existsSync2(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 (!existsSync2(root)) {
+      continue;
+    }
+    const state = layerState[layer];
+    for (const typeDir of STORE_KNOWLEDGE_TYPE_DIRS2) {
+      const dir = join2(root, typeDir);
+      for (const file of listMd(dir)) {
+        const source = join2(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 = readFileSync2(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 = parseKnowledgeId2(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 = parseKnowledgeId2(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 = join2(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 = join2(root, STORE_PENDING_DIR);
+    for (const sub of [".", "decisions", "guidelines", "pitfalls", "models", "processes"]) {
+      const dir = sub === "." ? pendingRoot : join2(pendingRoot, sub);
+      for (const file of listMd(dir)) {
+        const source = join2(dir, file);
+        if (state === void 0) {
+          skips.push({ source, reason: `no ${layer} write-target store` });
+          continue;
+        }
+        const rel = sub === "." ? file : join2(sub, file);
+        const targetFile = join2(
+          state.target.dir,
+          STORE_LAYOUT.knowledgeDir,
+          STORE_PENDING_DIR,
+          rel
+        );
+        if (existsSync2(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 = readFileSync2(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(join2(item.target, ".."), { recursive: true });
+    writeFileSync2(item.target, content, "utf8");
+  }
+  for (const item of items) {
+    rmSync(item.source, { force: true });
+  }
+  for (const info of Object.values(targets)) {
+    if (items.some((i) => i.storeUuid === info.uuid)) {
+      reconcileStoreCounters(info.dir);
+    }
+  }
+  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 (!existsSync2(join2(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/store/store-rescope.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join3 } from "path";
+import {
+  STORE_KNOWLEDGE_TYPE_DIRS as STORE_KNOWLEDGE_TYPE_DIRS3,
+  STORE_LAYOUT as STORE_LAYOUT2,
+  isPersonalScope as isPersonalScope2,
+  readStoreProjects,
+  scopeCoordinateSchema,
+  scopeRoot
+} from "@fenglimg/fabric-shared";
+function validateToScope(toScope, storeDir, storeVisibility) {
+  if (!scopeCoordinateSchema.safeParse(toScope).success) {
+    return `invalid scope coordinate '${toScope}'`;
+  }
+  if (isPersonalScope2(toScope) && storeVisibility === "shared") {
+    return "refusing personal scope in a shared store (R5#3 privacy boundary)";
+  }
+  if (scopeRoot(toScope) === "project") {
+    const projectId = toScope.split(":")[1] ?? "";
+    if (projectId.length === 0 || !readStoreProjects(storeDir).some((p) => p.id === projectId)) {
+      return `project '${projectId}' is not registered in this store (run \`fabric store project add ${projectId}\` first)`;
+    }
+  }
+  return null;
+}
+function matchesSelection(options, id, currentScope) {
+  if (options.id !== void 0 && id !== options.id) {
+    return false;
+  }
+  if (options.fromScope !== void 0 && currentScope !== options.fromScope) {
+    return false;
+  }
+  if (options.fromScopeRoot !== void 0 && (currentScope === void 0 || scopeRoot(currentScope) !== options.fromScopeRoot)) {
+    return false;
+  }
+  return true;
+}
+function rescopeStore(storeDir, toScope, options) {
+  const report = {
+    dryRun: options.dryRun === true,
+    toScope,
+    changes: [],
+    refusals: [],
+    unchanged: 0,
+    skipped: []
+  };
+  const toScopeError = validateToScope(toScope, storeDir, options.storeVisibility);
+  for (const type of STORE_KNOWLEDGE_TYPE_DIRS3) {
+    const dir = join3(storeDir, STORE_LAYOUT2.knowledgeDir, type);
+    if (!existsSync3(dir)) {
+      continue;
+    }
+    for (const name of readdirSync3(dir).filter((n) => n.endsWith(".md")).sort()) {
+      const file = join3(dir, name);
+      const content = readFileSync3(file, "utf8");
+      const match = FRONTMATTER_RE.exec(content);
+      if (match === null) {
+        report.skipped.push(file);
+        continue;
+      }
+      const block = match[1] ?? "";
+      const id = readKey(block, "id") ?? null;
+      const currentScope = readKey(block, "semantic_scope");
+      if (!matchesSelection(options, id, currentScope)) {
+        continue;
+      }
+      if (currentScope === toScope) {
+        report.unchanged += 1;
+        continue;
+      }
+      if (toScopeError !== null) {
+        report.refusals.push({ file, id, reason: toScopeError });
+        continue;
+      }
+      const newBlock = setKey(block, "semantic_scope", toScope, "layer");
+      const before = content.slice(0, match.index);
+      const after = content.slice(match.index + match[0].length);
+      report.changes.push({ file, id, fromScope: currentScope, toScope });
+      if (options.dryRun !== true) {
+        writeFileSync3(file, `${before}---
+${newBlock}
+---${after}`, "utf8");
+      }
+    }
+  }
+  return report;
+}
+function promoteProjectToTeam(storeDir, options) {
+  const selection = options.projectId !== void 0 ? { fromScope: `project:${options.projectId}`, storeVisibility: options.storeVisibility, dryRun: options.dryRun } : { fromScopeRoot: "project", storeVisibility: options.storeVisibility, dryRun: options.dryRun };
+  return rescopeStore(storeDir, "team", selection);
+}
+
+// src/commands/store.ts
+import {
+  STORE_LAYOUT as STORE_LAYOUT3,
+  loadGlobalConfig as loadGlobalConfig2,
+  resolveGlobalRoot as resolveGlobalRoot2
+} from "@fenglimg/fabric-shared";
+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" },
+    project: {
+      type: "string",
+      description: "Bind this repo to a project:<id> in the store (must already exist)"
+    }
+  },
+  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,
+      args.project === void 0 ? {} : { project: args.project }
+    );
+    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 projectListCommand = defineCommand({
+  meta: { name: "list", description: "List projects registered in a store" },
+  args: {
+    store: { type: "positional", required: true, description: "Store alias/UUID" }
+  },
+  run({ args }) {
+    const projects = storeProjectList(args.store);
+    if (projects.length === 0) {
+      console.log(`store '${args.store}' has no registered projects.`);
+      return;
+    }
+    for (const p of projects) {
+      console.log(`${p.id}${p.name === void 0 ? "" : `	${p.name}`}`);
+    }
+  }
+});
+var projectCreateCommand = defineCommand({
+  meta: { name: "create", description: "Register a new project in a store" },
+  args: {
+    store: { type: "positional", required: true, description: "Store alias/UUID" },
+    id: { type: "positional", required: true, description: "Project id (single [a-z0-9_-] segment)" },
+    name: { type: "string", description: "Optional human-facing label" }
+  },
+  run({ args }) {
+    const project = storeProjectCreate(args.store, args.id, (/* @__PURE__ */ new Date()).toISOString(), {
+      ...args.name === void 0 ? {} : { name: args.name }
+    });
+    console.log(`registered project '${project.id}' in store '${args.store}'.`);
+  }
+});
+var projectCommand = defineCommand({
+  meta: { name: "project", description: "Manage the projects a store serves" },
+  subCommands: {
+    list: projectListCommand,
+    create: projectCreateCommand
+  }
+});
+var backfillScopeCommand = defineCommand({
+  meta: {
+    name: "backfill-scope",
+    description: "Backfill semantic_scope + visibility_store on existing knowledge (repairs dirty layer)"
+  },
+  args: {
+    store: { type: "string", description: "Backfill a mounted store's knowledge instead of the project" },
+    "dry-run": { type: "boolean", description: "Preview changes without writing" }
+  },
+  run({ args }) {
+    const dryRun = args["dry-run"] === true;
+    let knowledgeDir;
+    let visibilityStore;
+    if (typeof args.store === "string" && args.store.length > 0) {
+      const storeDir = resolveStoreDir(args.store);
+      if (storeDir === null) {
+        console.error(`no mounted store '${args.store}'`);
+        process.exitCode = 1;
+        return;
+      }
+      knowledgeDir = join4(storeDir, STORE_LAYOUT3.knowledgeDir);
+      visibilityStore = args.store;
+    } else {
+      const projectRoot = process.cwd();
+      knowledgeDir = join4(projectRoot, ".fabric", "knowledge");
+      visibilityStore = loadProjectConfig(projectRoot)?.active_write_store ?? "team";
+    }
+    const report = backfillKnowledgeDir(knowledgeDir, { visibilityStore, dryRun });
+    if (report.changes.length === 0) {
+      console.log(`scope backfill: nothing to do (${report.unchanged} already consistent).`);
+      return;
+    }
+    console.log(
+      `${dryRun ? "[dry-run] " : ""}scope backfill: ${report.changes.length} entr${report.changes.length === 1 ? "y" : "ies"} updated, ${report.unchanged} unchanged.`
+    );
+    for (const c of report.changes) {
+      console.log(`  ${c.id ?? "(no id)"}  [${c.changed.join(", ")}]`);
+    }
+  }
+});
+function resolveStoreDirAndVisibility(aliasOrUuid) {
+  const dir = resolveStoreDir(aliasOrUuid);
+  if (dir === null) {
+    return null;
+  }
+  const store = loadGlobalConfig2(resolveGlobalRoot2())?.stores.find(
+    (s) => s.alias === aliasOrUuid || s.store_uuid === aliasOrUuid
+  );
+  return { dir, visibility: store?.personal === true ? "personal" : "shared" };
+}
+function printRescopeReport(report) {
+  const prefix = report.dryRun ? "[dry-run] " : "";
+  if (report.changes.length === 0 && report.refusals.length === 0) {
+    console.log(`re-scope: nothing to do (${report.unchanged} already at '${report.toScope}').`);
+  } else if (report.changes.length > 0) {
+    console.log(
+      `${prefix}re-scope \u2192 ${report.toScope}: ${report.changes.length} entr${report.changes.length === 1 ? "y" : "ies"} updated, ${report.unchanged} unchanged.`
+    );
+    for (const c of report.changes) {
+      console.log(`  ${c.id ?? "(no id)"}  ${c.fromScope ?? "(none)"} \u2192 ${c.toScope}`);
+    }
+  }
+  if (report.refusals.length > 0) {
+    console.error(`${report.refusals.length} entr${report.refusals.length === 1 ? "y" : "ies"} refused:`);
+    for (const r of report.refusals) {
+      console.error(`  ${r.id ?? "(no id)"}: ${r.reason}`);
+    }
+    process.exitCode = 1;
+  }
+}
+var rescopeCommand = defineCommand({
+  meta: {
+    name: "re-scope",
+    description: "Rewrite knowledge entries' semantic_scope coordinate in a store"
+  },
+  args: {
+    store: { type: "positional", required: true, description: "Target store alias or uuid" },
+    to: { type: "string", required: true, description: "New semantic_scope (e.g. team, project:alpha)" },
+    id: { type: "string", description: "Only the entry with this stable_id" },
+    from: { type: "string", description: "Only entries currently at this semantic_scope" },
+    "dry-run": { type: "boolean", description: "Preview changes without writing" }
+  },
+  run({ args }) {
+    const resolved = resolveStoreDirAndVisibility(args.store);
+    if (resolved === null) {
+      console.error(`no mounted store '${args.store}'`);
+      process.exitCode = 1;
+      return;
+    }
+    printRescopeReport(
+      rescopeStore(resolved.dir, args.to, {
+        id: args.id,
+        fromScope: args.from,
+        storeVisibility: resolved.visibility,
+        dryRun: args["dry-run"] === true
+      })
+    );
+  }
+});
+var promoteCommand = defineCommand({
+  meta: {
+    name: "promote",
+    description: "Promote project-scoped entries to team scope (project absorption)"
+  },
+  args: {
+    store: { type: "positional", required: true, description: "Target store alias or uuid" },
+    project: { type: "string", description: "Only this project's entries (default: all project:*)" },
+    "dry-run": { type: "boolean", description: "Preview changes without writing" }
+  },
+  run({ args }) {
+    const resolved = resolveStoreDirAndVisibility(args.store);
+    if (resolved === null) {
+      console.error(`no mounted store '${args.store}'`);
+      process.exitCode = 1;
+      return;
+    }
+    printRescopeReport(
+      promoteProjectToTeam(resolved.dir, {
+        projectId: args.project,
+        storeVisibility: resolved.visibility,
+        dryRun: args["dry-run"] === true
+      })
+    );
+  }
+});
+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,
+    "backfill-scope": backfillScopeCommand,
+    "re-scope": rescopeCommand,
+    promote: promoteCommand,
+    project: projectCommand
+  }
+});
+export {
+  store_default as default
+};