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

package/dist/{chunk-5SSNE5GM.js → chunk-QPAW6IYT.js}

@@ -1,28 +1,40 @@
 #!/usr/bin/env node
 import {
-  loadGlobalConfig,
   loadProjectConfig,
-  resolveGlobalRoot,
-  saveGlobalConfig,
   saveProjectConfig
-} from "./chunk-XCBVSGCS.js";
+} from "./chunk-QFIVFZRH.js";
+import {
+  loadGlobalConfig,
+  resolveGlobalRoot,
+  saveGlobalConfig
+} from "./chunk-FNHDQTPC.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 { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, readlinkSync, rmSync, symlinkSync, writeFileSync } from "fs";
 import { join } from "path";
 import {
   addMountedStore,
   addStoreProject,
   bindRequiredStore,
+  deriveMountLabel,
   detachMountedStore,
   explainStore,
   initStore,
-  readStoreProjects,
+  STORE_GITIGNORE,
+  STORE_KNOWLEDGE_TYPE_DIRS,
+  STORE_LAYOUT,
+  STORE_PENDING_DIR,
   STORES_ROOT_DIR,
   storeHasProject,
-  storeRelativePath
+  storeIdentitySchema,
+  storeProjectsFileSchema,
+  storeMountSubPath,
+  storeRelativePath,
+  storeRelativePathForMount,
+  storeMountNameSchema,
+  writeRouteSchema
 } from "@fenglimg/fabric-shared";
 var NO_GLOBAL_CONFIG = "no global Fabric config found \u2014 run `fabric install --global <url>` first";
 function requireConfig(globalRoot) {
@@ -35,6 +47,18 @@ function requireConfig(globalRoot) {
 function storeList(globalRoot = resolveGlobalRoot()) {
   return requireConfig(globalRoot).stores;
 }
+function mountedStoreDir(store, globalRoot) {
+  return join(globalRoot, storeRelativePathForMount(store));
+}
+function resolveStoreByAliasOrUuid(aliasOrUuid, globalRoot = resolveGlobalRoot()) {
+  const config = loadGlobalConfig(globalRoot);
+  if (config === null) {
+    return null;
+  }
+  return config.stores.find(
+    (s) => s.alias === aliasOrUuid || s.store_uuid === aliasOrUuid || s.mount_name === aliasOrUuid
+  ) ?? null;
+}
 var STORE_BY_ALIAS_DIR = "by-alias";
 function syncStoreAliasLinks(globalRoot = resolveGlobalRoot()) {
   const result = { created: [], removed: [], errors: [] };
@@ -43,7 +67,7 @@ function syncStoreAliasLinks(globalRoot = resolveGlobalRoot()) {
     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]));
+  const desired = new Map(config.stores.map((s) => [s.alias, storeMountSubPath(s)]));
   try {
     mkdirSync(byAliasDir, { recursive: true });
   } catch {
@@ -66,9 +90,9 @@ function syncStoreAliasLinks(globalRoot = resolveGlobalRoot()) {
       result.errors.push(name);
     }
   }
-  for (const [alias, uuid] of desired) {
+  for (const [alias, mountName] of desired) {
     const link = join(byAliasDir, alias);
-    const target = join("..", uuid);
+    const target = join("..", mountName);
     try {
       let current = null;
       try {
@@ -102,7 +126,7 @@ function detectAliasLinkDrift(globalRoot = resolveGlobalRoot()) {
   const drifted = [];
   for (const store of config.stores) {
     const link = join(byAliasDir, store.alias);
-    const target = join("..", store.store_uuid);
+    const target = join("..", storeMountSubPath(store));
     try {
       if (!lstatSync(link).isSymbolicLink() || readlinkSync(link) !== target) {
         drifted.push(store.alias);
@@ -119,25 +143,47 @@ function storeAdd(store, globalRoot = resolveGlobalRoot()) {
   syncStoreAliasLinks(globalRoot);
   return next;
 }
-function storeCreate(alias, now, options = {}) {
+async 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 }
-  );
+  const mount_name = options.mountName !== void 0 ? storeMountNameSchema.parse(options.mountName) : deriveMountLabel({ remote: options.remote, alias, store_uuid: uuid });
+  const mountedBase = { store_uuid: uuid, alias, mount_name };
+  const storeDir = mountedStoreDir(mountedBase, globalRoot);
+  const identity = { store_uuid: uuid, created_at: now, canonical_alias: alias };
+  if (options.git === false) {
+    initStoreSync(storeDir, identity);
+  } else {
+    await initStore(storeDir, identity, { 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 mounted = options.remote === void 0 ? mountedBase : { ...mountedBase, remote: options.remote };
   const next = addMountedStore(config, mounted);
   saveGlobalConfig(next, globalRoot);
   syncStoreAliasLinks(globalRoot);
   return { config: next, store_uuid: uuid, storeDir };
 }
+function initStoreSync(absDir, identity) {
+  const parsed = storeIdentitySchema.parse(identity);
+  const identityFile = join(absDir, STORE_LAYOUT.identityFile);
+  if (existsSync(identityFile)) {
+    throw new Error(`store already initialized at ${absDir} (store.json exists)`);
+  }
+  for (const type of STORE_KNOWLEDGE_TYPE_DIRS) {
+    const typeDir = join(absDir, STORE_LAYOUT.knowledgeDir, type);
+    mkdirSync(typeDir, { recursive: true });
+    writeFileSync(join(typeDir, ".gitkeep"), "", "utf8");
+  }
+  mkdirSync(join(absDir, STORE_LAYOUT.knowledgeDir, STORE_PENDING_DIR), { recursive: true });
+  mkdirSync(join(absDir, STORE_LAYOUT.bindingsDir), { recursive: true });
+  mkdirSync(join(absDir, STORE_LAYOUT.stateDir), { recursive: true });
+  writeFileSync(identityFile, `${JSON.stringify(parsed, null, 2)}
+`, "utf8");
+  writeFileSync(join(absDir, ".gitignore"), STORE_GITIGNORE, "utf8");
+  return parsed;
+}
 function gitRemoteAdd(storeDir, remote) {
   try {
     execFileSync("git", ["remote", "add", "origin", remote], {
@@ -154,8 +200,8 @@ function gitRemoteAdd(storeDir, remote) {
     }
   }
 }
-function storeGitRemote(uuid, globalRoot = resolveGlobalRoot()) {
-  const storeDir = join(globalRoot, storeRelativePath(uuid));
+function storeGitRemote(aliasOrUuid, globalRoot = resolveGlobalRoot()) {
+  const storeDir = resolveStoreDir(aliasOrUuid, globalRoot) ?? join(globalRoot, storeRelativePath(aliasOrUuid));
   if (!existsSync(storeDir)) {
     return void 0;
   }
@@ -171,8 +217,20 @@ function storeGitRemote(uuid, globalRoot = resolveGlobalRoot()) {
     return void 0;
   }
 }
-function assertStoreMountable(uuid, globalRoot = resolveGlobalRoot()) {
-  const storeDir = join(globalRoot, storeRelativePath(uuid));
+function assertStoreMountable(uuid, globalRoot = resolveGlobalRoot(), mountName) {
+  const registered = resolveStoreByAliasOrUuid(uuid, globalRoot);
+  const candidates = mountName === void 0 && registered === null ? [join(globalRoot, storeRelativePath(uuid))] : [
+    join(
+      globalRoot,
+      storeRelativePathForMount({
+        store_uuid: uuid,
+        mount_name: mountName ?? registered?.mount_name,
+        personal: registered?.personal
+      })
+    ),
+    join(globalRoot, storeRelativePath(uuid))
+  ];
+  const storeDir = candidates.find((dir) => existsSync(join(dir, "store.json"))) ?? candidates[0];
   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.`
@@ -197,36 +255,40 @@ function requireProjectConfig(projectRoot) {
   return config;
 }
 function resolveStoreDir(aliasOrUuid, globalRoot = resolveGlobalRoot()) {
-  const config = loadGlobalConfig(globalRoot);
-  if (config === null) {
+  const store = resolveStoreByAliasOrUuid(aliasOrUuid, globalRoot);
+  if (store === null) {
     return null;
   }
-  const store = config.stores.find(
-    (s) => s.alias === aliasOrUuid || s.store_uuid === aliasOrUuid
-  );
-  if (store === void 0) {
-    return null;
-  }
-  return join(globalRoot, storeRelativePath(store.store_uuid));
+  return mountedStoreDir(store, globalRoot);
 }
 function storeProjectList(aliasOrUuid, globalRoot = resolveGlobalRoot()) {
   const storeDir = resolveStoreDir(aliasOrUuid, globalRoot);
   if (storeDir === null) {
     throw new Error(`no mounted store '${aliasOrUuid}' \u2014 run \`fabric store list\` to see mounts`);
   }
-  return readStoreProjects(storeDir);
+  return readStoreProjectsSync(storeDir);
+}
+function readStoreProjectsSync(storeDir) {
+  try {
+    const parsed = storeProjectsFileSchema.safeParse(
+      JSON.parse(readFileSync(join(storeDir, STORE_LAYOUT.projectsFile), "utf8"))
+    );
+    return parsed.success ? parsed.data.projects : [];
+  } catch {
+    return [];
+  }
 }
-function storeProjectCreate(aliasOrUuid, id, now, options = {}) {
+async function storeProjectCreate(aliasOrUuid, id, now, options = {}) {
   const globalRoot = options.globalRoot ?? resolveGlobalRoot();
   const storeDir = resolveStoreDir(aliasOrUuid, globalRoot);
   if (storeDir === null) {
     throw new Error(`no mounted store '${aliasOrUuid}' \u2014 run \`fabric store list\` to see mounts`);
   }
   const project = options.name === void 0 ? { id, created_at: now } : { id, name: options.name, created_at: now };
-  addStoreProject(storeDir, project);
+  await addStoreProject(storeDir, project);
   return project;
 }
-function storeBind(projectRoot, entry, options = {}) {
+async function storeBind(projectRoot, entry, options = {}) {
   const config = requireProjectConfig(projectRoot);
   let activeProject = config.active_project;
   if (options.project !== void 0) {
@@ -237,7 +299,7 @@ function storeBind(projectRoot, entry, options = {}) {
         `cannot bind project '${options.project}': store '${entry.id}' is not mounted \u2014 mount it first (\`fabric store add\` / \`fabric install --global --url <remote>\`)`
       );
     }
-    if (!storeHasProject(storeDir, options.project)) {
+    if (!await storeHasProject(storeDir, options.project)) {
       throw new Error(
         `cannot bind to project '${options.project}': not registered in store '${entry.id}' \u2014 create it first with \`fabric store project create ${entry.id} ${options.project}\``
       );
@@ -252,9 +314,32 @@ function storeBind(projectRoot, entry, options = {}) {
   saveProjectConfig(next, projectRoot);
   return next;
 }
-function storeSwitchWrite(projectRoot, alias) {
+function storeSwitchWrite(projectRoot, alias, options = {}) {
   const config = requireProjectConfig(projectRoot);
-  const next = { ...config, active_write_store: alias };
+  const store = resolveStoreByAliasOrUuid(alias, options.globalRoot ?? resolveGlobalRoot());
+  if (store === null || store.personal === true || store.writable === false) {
+    throw new Error(`cannot set default write store '${alias}': mount a writable shared store first`);
+  }
+  const next = {
+    ...config,
+    active_write_store: alias,
+    default_write_store: alias
+  };
+  saveProjectConfig(next, projectRoot);
+  return next;
+}
+function storeSetWriteRoute(projectRoot, scope, alias, options = {}) {
+  const config = requireProjectConfig(projectRoot);
+  const route = writeRouteSchema.parse({ scope, store: alias });
+  const store = resolveStoreByAliasOrUuid(alias, options.globalRoot ?? resolveGlobalRoot());
+  if (store === null || store.personal === true || store.writable === false) {
+    throw new Error(`cannot route scope '${scope}' to '${alias}': mount a writable shared store first`);
+  }
+  const routes = [
+    ...(config.write_routes ?? []).filter((existing) => existing.scope !== route.scope),
+    route
+  ];
+  const next = { ...config, write_routes: routes };
   saveProjectConfig(next, projectRoot);
   return next;
 }
@@ -296,6 +381,7 @@ export {
   storeProjectCreate,
   storeBind,
   storeSwitchWrite,
+  storeSetWriteRoute,
   missingRequiredStores,
   unboundAvailableStores
 };

package/dist/{chunk-COI5VDFU.js → chunk-WA3DYGSY.js}

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 
 // src/dev-mode.ts
-import { existsSync, readFileSync } from "fs";
-import { isAbsolute, join, resolve } from "path";
+import { isAbsolute, resolve } from "path";
 function resolveDevMode(cliTarget, workspaceRoot = process.cwd()) {
   const envTarget = normalizeTarget(process.env.EXTERNAL_FIXTURE_PATH, workspaceRoot);
   const directTarget = normalizeTarget(cliTarget, workspaceRoot);

package/dist/{plan-context-hint-CHVZGOZ5.js → chunk-YM4XATJF.js}

@@ -1,11 +1,15 @@
 #!/usr/bin/env node
 import {
   resolveDevMode
-} from "./chunk-COI5VDFU.js";
+} from "./chunk-WA3DYGSY.js";
 
 // src/commands/plan-context-hint.ts
 import { defineCommand } from "citty";
-import { planContext } from "@fenglimg/fabric-server";
+import {
+  buildAlwaysActiveBodies,
+  buildKnowledgeCensus,
+  planContext
+} from "@fenglimg/fabric-server";
 var ALL_PATHS_SENTINEL = "**";
 var planContextHintCommand = defineCommand({
   meta: {
@@ -74,6 +78,9 @@ async function runPlanContextHint(opts) {
       maturity: item.description.maturity ?? "",
       summary: item.description.summary,
       relevance_scope: item.description.relevance_scope ?? "broad",
+      // W2-2 (KT-DEC-0027): forward the must_read_if trigger hook for the
+      // SessionStart REFERENCE rendering. Omitted when absent/empty.
+      ...typeof item.description.must_read_if === "string" && item.description.must_read_if.length > 0 ? { must_read_if: item.description.must_read_if } : {},
       // Only set when this entry was pulled in via a graph edge — its presence
       // is the honest signal, never synthesized for ordinarily-ranked entries.
       ...typeof relatedTo === "string" ? { related_to: relatedTo } : {}
@@ -85,6 +92,15 @@ async function runPlanContextHint(opts) {
     if (e.relevance_scope === "narrow") narrow_count += 1;
     else broad_only_count += 1;
   }
+  const alwaysBodies = await buildAlwaysActiveBodies(resolution.target).catch(() => []);
+  const census = await buildKnowledgeCensus(resolution.target).catch(
+    () => ({
+      by_type: {},
+      by_layer: { team: 0, personal: 0, project: 0 },
+      dropped_other_project: 0,
+      total: 0
+    })
+  );
   const output = {
     version: 2,
     revision_hash: result.revision_hash,
@@ -94,7 +110,15 @@ async function runPlanContextHint(opts) {
     // semantics unchanged from rc.18 (total candidate count).
     broad_count: candidates.length,
     narrow_count,
-    broad_only_count
+    broad_only_count,
+    always_bodies: alwaysBodies.map((b) => ({
+      id: b.stable_id,
+      type: b.type,
+      layer: b.layer,
+      summary: b.summary,
+      body: b.body
+    })),
+    census
   };
   if (result.auto_healed === true) {
     output.auto_healed = true;
@@ -110,8 +134,9 @@ function parsePathsArg(raw) {
   }
   return raw.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
 }
+
 export {
-  plan_context_hint_default as default,
   planContextHintCommand,
+  plan_context_hint_default,
   runPlanContextHint
 };

package/dist/{config-VJMXCLXW.js → config-A3LTECAY.js}

@@ -3,9 +3,10 @@ import {
   configCmd,
   config_default,
   installMcpClients
-} from "./chunk-F6ITRM7T.js";
-import "./chunk-XC5RUHLK.js";
-import "./chunk-2CY4BMTH.js";
+} from "./chunk-2KBCTMID.js";
+import "./chunk-3IOLS5EK.js";
+import "./chunk-FNHDQTPC.js";
+import "./chunk-HORSMSZL.js";
 export {
   configCmd,
   config_default as default,

package/dist/context-7NUKXDB6.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+import {
+  runPlanContextHint
+} from "./chunk-YM4XATJF.js";
+import "./chunk-WA3DYGSY.js";
+
+// src/commands/context.ts
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join, parse, resolve } from "path";
+import { fileURLToPath } from "url";
+import { defineCommand } from "citty";
+function findTemplatePath(relativePath) {
+  const startDir = dirname(fileURLToPath(import.meta.url));
+  let current = resolve(startDir);
+  for (; ; ) {
+    const candidate = join(current, "templates", relativePath);
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(current);
+    if (parent === current || parse(current).root === current) {
+      throw new Error(`Template not found: templates/${relativePath} (searched up from ${startDir})`);
+    }
+    current = parent;
+  }
+}
+function loadHookRenderer() {
+  const require2 = createRequire(import.meta.url);
+  return require2(findTemplatePath("hooks/knowledge-hint-broad.cjs"));
+}
+function renderExplain(sinks) {
+  const payload = sinks.resolvedPayload;
+  const lines = ["", "\u2014 explain (provenance; not injected) \u2014"];
+  const bodies = Array.isArray(payload?.always_bodies) ? payload.always_bodies : [];
+  if (bodies.length > 0) {
+    lines.push("always-active (body injected):");
+    for (const b of bodies) {
+      lines.push(`  [${b.type}] ${b.id} (${b.layer}) \xB7 ${b.summary}`);
+    }
+  }
+  const entries = Array.isArray(payload?.entries) ? payload.entries : [];
+  if (entries.length > 0) {
+    lines.push("reference / candidates:");
+    for (const e of entries) {
+      const provenance = typeof e.related_to === "string" ? ` \u2190related-to:${e.related_to}` : "";
+      lines.push(
+        `  [${e.type}] ${e.id} (${e.maturity || "?"}, ${e.relevance_scope})${provenance} \xB7 ${e.summary}`
+      );
+      if (typeof e.must_read_if === "string" && e.must_read_if.length > 0) {
+        lines.push(`    must_read_if: ${e.must_read_if}`);
+      }
+    }
+  }
+  const census = payload?.census;
+  if (census) {
+    const layer = census.by_layer ?? { team: 0, personal: 0, project: 0 };
+    lines.push(
+      `census: total ${census.total} \xB7 [team]${layer.team ?? 0} [project]${layer.project ?? 0} [personal]${layer.personal ?? 0}`
+    );
+  }
+  return lines.join("\n");
+}
+async function runContext(opts) {
+  const cwd = opts.target ? resolve(opts.target) : process.cwd();
+  const payload = opts.payload !== void 0 ? opts.payload : await runPlanContextHint({ all: true, target: opts.target });
+  const renderer = loadHookRenderer();
+  const sinks = renderer.buildSessionStartSinks(cwd, payload, {});
+  let base;
+  if (opts.render === "ai") {
+    base = sinks.ai ?? "";
+  } else if (opts.render === "human") {
+    base = sinks.human ?? "";
+  } else {
+    base = [sinks.human, sinks.ai].filter((s) => typeof s === "string" && s.length > 0).join("\n\n");
+  }
+  if (base.length === 0 && !sinks.hasRenderedContent) return "";
+  return opts.explain === true ? base + "\n" + renderExplain(sinks) : base;
+}
+var contextCommand = defineCommand({
+  meta: {
+    name: "context",
+    description: "Show what Fabric injects at SessionStart (the knowledge spine). --explain for per-entry provenance."
+  },
+  args: {
+    render: {
+      type: "string",
+      description: "Which sink to show: 'human' (systemMessage) or 'ai' (additionalContext). Default: both."
+    },
+    explain: {
+      type: "boolean",
+      description: "Append a per-entry provenance section (id \xB7 type \xB7 maturity \xB7 scope \xB7 why-surfaced).",
+      default: false
+    },
+    target: {
+      type: "string",
+      description: "Override the project root (defaults to cwd / dev-mode resolution)."
+    }
+  },
+  async run({ args }) {
+    try {
+      const render = args.render === "human" || args.render === "ai" ? args.render : void 0;
+      const out = await runContext({ render, explain: args.explain === true, target: args.target });
+      if (out.length > 0) process.stdout.write(`${out}
+`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`context failed: ${message}
+`);
+      process.exitCode = 1;
+    }
+  }
+});
+var context_default = contextCommand;
+export {
+  contextCommand,
+  context_default as default,
+  runContext
+};

package/dist/doctor-MDTZWKBK.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import {
+  doctorCommand,
+  doctor_default,
+  parseSinceDuration,
+  renderDoctorFilteredHelp,
+  renderTldrHeader
+} from "./chunk-E7HJUU34.js";
+import "./chunk-3D7B2UAZ.js";
+import "./chunk-WA3DYGSY.js";
+import "./chunk-NLNH64A3.js";
+import "./chunk-PTGQAZEW.js";
+import "./chunk-EOT63RDH.js";
+import "./chunk-QPAW6IYT.js";
+import "./chunk-QFIVFZRH.js";
+import "./chunk-FNHDQTPC.js";
+import "./chunk-HORSMSZL.js";
+export {
+  doctor_default as default,
+  doctorCommand,
+  parseSinceDuration,
+  renderDoctorFilteredHelp,
+  renderTldrHeader
+};

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import * as citty from 'citty';
+import { CommandDef, ArgsDef } from 'citty';
 
-declare const main: citty.CommandDef<citty.ArgsDef>;
+declare const main: CommandDef<ArgsDef>;
 declare function run(): Promise<void>;
 
 export { main, run };