@fenglimg/fabric-cli 2.0.0 → 2.1.0-rc.2

package/dist/metrics-ACEQFPDU.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+
+// src/commands/metrics.ts
+import { resolve } from "path";
+import { defineCommand } from "citty";
+import { readMetrics } from "@fenglimg/fabric-server";
+function parseSinceArg(raw) {
+  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)`);
+  }
+  const n = Number.parseInt(match[1], 10);
+  const unit = match[2] ?? "s";
+  const multipliers = { s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
+  return n * (multipliers[unit] ?? 1e3);
+}
+function aggregate(rows, sinceMs, now) {
+  const cutoff = sinceMs > 0 ? now.getTime() - sinceMs : 0;
+  const filtered = rows.filter((r) => {
+    if (cutoff === 0) return true;
+    const ts = Date.parse(r.timestamp);
+    return Number.isFinite(ts) && ts >= cutoff;
+  });
+  const totals = {};
+  const perEntryConsumed = {};
+  for (const row of filtered) {
+    for (const [name, count] of Object.entries(row.counters)) {
+      if (name.startsWith("knowledge_consumed:")) {
+        const id = name.slice("knowledge_consumed:".length);
+        perEntryConsumed[id] = (perEntryConsumed[id] ?? 0) + count;
+        totals["knowledge_consumed"] = (totals["knowledge_consumed"] ?? 0) + count;
+        continue;
+      }
+      totals[name] = (totals[name] ?? 0) + count;
+    }
+  }
+  return {
+    windowDescription: sinceMs > 0 ? formatDuration(sinceMs) : "all-time",
+    rowCount: filtered.length,
+    totals,
+    perEntryConsumed,
+    rangeStart: filtered[0]?.timestamp ?? null,
+    rangeEnd: filtered[filtered.length - 1]?.timestamp ?? null
+  };
+}
+function formatDuration(ms) {
+  if (ms >= 864e5) return `${Math.round(ms / 864e5)}d`;
+  if (ms >= 36e5) return `${Math.round(ms / 36e5)}h`;
+  if (ms >= 6e4) return `${Math.round(ms / 6e4)}m`;
+  return `${Math.round(ms / 1e3)}s`;
+}
+function renderText(agg) {
+  const lines = [];
+  lines.push(`Fabric metrics \u2014 window: ${agg.windowDescription}`);
+  if (agg.rangeStart && agg.rangeEnd) {
+    lines.push(`  rows: ${agg.rowCount} (${agg.rangeStart} \u2192 ${agg.rangeEnd})`);
+  } else {
+    lines.push(`  rows: ${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)");
+    return lines.join("\n");
+  }
+  lines.push("  counter                              total");
+  lines.push("  ------------------------------------ ----------");
+  const sorted = Object.entries(agg.totals).sort((a, b) => b[1] - a[1]);
+  for (const [name, count] of sorted) {
+    lines.push(`  ${name.padEnd(36)} ${String(count).padStart(10)}`);
+  }
+  const perEntrySorted = Object.entries(agg.perEntryConsumed).sort((a, b) => b[1] - a[1]).slice(0, 10);
+  if (perEntrySorted.length > 0) {
+    lines.push("");
+    lines.push("  Top per-entry consumed (knowledge_consumed:<id>)");
+    lines.push("  ------------------------------------ ----------");
+    for (const [id, count] of perEntrySorted) {
+      lines.push(`  ${id.padEnd(36)} ${String(count).padStart(10)}`);
+    }
+  }
+  return lines.join("\n");
+}
+var metricsCommand = defineCommand({
+  meta: {
+    name: "metrics",
+    description: "Print a text dashboard of Fabric counter activity from .fabric/metrics.jsonl",
+    hidden: true
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Emit machine-readable JSON instead of the text table.",
+      default: false
+    },
+    target: {
+      type: "string",
+      description: "Project root (defaults to the current working directory)."
+    },
+    since: {
+      type: "string",
+      description: "Limit to rows within a recent window. Examples: 24h, 7d, 30m, 90s. Omit for all-time."
+    }
+  },
+  async run({ args }) {
+    const projectRoot = resolve(args.target ?? process.cwd());
+    const sinceMs = parseSinceArg(args.since);
+    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)}
+`);
+    }
+  }
+});
+var metrics_default = metricsCommand;
+export {
+  metrics_default as default,
+  metricsCommand
+};

package/dist/onboard-coverage-MFCAEBDO.js

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+import {
+  t
+} from "./chunk-PWLW3B57.js";
+
+// src/commands/onboard-coverage.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join, resolve } from "path";
+import { defineCommand } from "citty";
+import {
+  ONBOARD_SLOT_NAMES,
+  ONBOARD_SLOT_TOTAL
+} from "@fenglimg/fabric-shared";
+var KNOWLEDGE_TYPE_DIRS = [
+  "decisions",
+  "pitfalls",
+  "guidelines",
+  "models",
+  "processes"
+];
+var FABRIC_CONFIG_PATH = [".fabric", "fabric-config.json"];
+function emptyFilled() {
+  const filled = {};
+  for (const slot of ONBOARD_SLOT_NAMES) {
+    filled[slot] = [];
+  }
+  return filled;
+}
+function readOnboardSlotFrontmatter(filePath) {
+  let content;
+  try {
+    content = readFileSync(filePath, "utf8");
+  } catch {
+    return void 0;
+  }
+  const match = /^---\n([\s\S]*?)\n---/u.exec(content);
+  if (match === null) return void 0;
+  const block = match[1];
+  if (block === void 0) return void 0;
+  for (const rawLine of block.split(/\r?\n/u)) {
+    const line = rawLine.trim();
+    const sep = line.indexOf(":");
+    if (sep === -1) continue;
+    const key = line.slice(0, sep).trim();
+    if (key !== "onboard_slot") continue;
+    let value = line.slice(sep + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') && value.length >= 2) {
+      value = value.slice(1, -1);
+    }
+    return value;
+  }
+  return void 0;
+}
+function readStableIdFrontmatter(filePath, fallbackName) {
+  let content;
+  try {
+    content = readFileSync(filePath, "utf8");
+  } catch {
+    return fallbackName.replace(/\.md$/u, "");
+  }
+  const match = /^---\n([\s\S]*?)\n---/u.exec(content);
+  if (match === null) return fallbackName.replace(/\.md$/u, "");
+  const block = match[1];
+  if (block === void 0) return fallbackName.replace(/\.md$/u, "");
+  for (const rawLine of block.split(/\r?\n/u)) {
+    const line = rawLine.trim();
+    const sep = line.indexOf(":");
+    if (sep === -1) continue;
+    if (line.slice(0, sep).trim() !== "id") continue;
+    return line.slice(sep + 1).trim();
+  }
+  return fallbackName.replace(/\.md$/u, "");
+}
+function readOptedOutSlots(projectRoot) {
+  const path = join(projectRoot, ...FABRIC_CONFIG_PATH);
+  if (!existsSync(path)) return [];
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch {
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    process.stderr.write(
+      `onboard-coverage: ignoring malformed fabric-config.json (${err instanceof Error ? err.message : String(err)})
+`
+    );
+    return [];
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return [];
+  }
+  const slots = parsed.onboard_slots_opted_out;
+  if (!Array.isArray(slots)) return [];
+  return slots.filter((v) => typeof v === "string");
+}
+function runOnboardCoverage(projectRoot) {
+  const filled = emptyFilled();
+  const knowledgeRoot = join(projectRoot, ".fabric", "knowledge");
+  if (existsSync(knowledgeRoot)) {
+    for (const typeDir of KNOWLEDGE_TYPE_DIRS) {
+      const dir = join(knowledgeRoot, typeDir);
+      if (!existsSync(dir)) continue;
+      let entries;
+      try {
+        entries = readdirSync(dir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        if (!entry.isFile()) continue;
+        if (!entry.name.endsWith(".md")) continue;
+        const filePath = join(dir, entry.name);
+        const slot = readOnboardSlotFrontmatter(filePath);
+        if (slot === void 0) continue;
+        if (!ONBOARD_SLOT_NAMES.includes(slot)) continue;
+        const stableId = readStableIdFrontmatter(filePath, entry.name);
+        filled[slot].push(stableId);
+      }
+    }
+  }
+  const optedOut = readOptedOutSlots(projectRoot);
+  const missing = ONBOARD_SLOT_NAMES.filter((slot) => {
+    if (filled[slot].length > 0) return false;
+    if (optedOut.includes(slot)) return false;
+    return true;
+  });
+  for (const slot of ONBOARD_SLOT_NAMES) {
+    filled[slot].sort();
+  }
+  return {
+    filled,
+    missing,
+    opted_out: optedOut,
+    total: ONBOARD_SLOT_TOTAL
+  };
+}
+function renderHumanReadable(report) {
+  const filledCount = ONBOARD_SLOT_NAMES.filter(
+    (slot) => report.filled[slot].length > 0
+  ).length;
+  const optedOutCount = report.opted_out.length;
+  const missingCount = report.missing.length;
+  const lines = [];
+  lines.push(
+    `Onboard coverage: ${filledCount}/${report.total} filled, ${optedOutCount} opted-out, ${missingCount} missing`
+  );
+  lines.push("");
+  lines.push("  slot                       status      entries");
+  lines.push("  -------------------------- ----------- -------------------------");
+  for (const slot of ONBOARD_SLOT_NAMES) {
+    const entries = report.filled[slot];
+    let status;
+    let detail;
+    if (entries.length > 0) {
+      status = "filled";
+      detail = entries.join(", ");
+    } else if (report.opted_out.includes(slot)) {
+      status = "opted-out";
+      detail = "(user-dismissed; run `fabric config onboard-reset` to re-open)";
+    } else {
+      status = "missing";
+      detail = "(run /fabric-archive to onboard)";
+    }
+    lines.push(`  ${slot.padEnd(26)} ${status.padEnd(11)} ${detail}`);
+  }
+  return lines.join("\n");
+}
+var onboardCoverageCommand = defineCommand({
+  meta: {
+    name: "onboard-coverage",
+    // v2.0.0-rc.29 TASK-008 (BUG-L2): route description strings through t()
+    // (mirrors serve.ts pattern). Previously this command was English-only
+    // even when the rest of `fabric --help` rendered zh-CN, so Chinese-locale
+    // users saw an isolated English block under --help.
+    description: t("cli.onboard-coverage.description"),
+    // Mirrors `plan-context-hint`: hidden from `fabric --help` so the top-level
+    // banner stays focused on install/doctor/serve/config. The command stays
+    // callable directly from Skills via `fabric onboard-coverage --json`.
+    hidden: true
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: t("cli.onboard-coverage.args.json.description"),
+      default: false
+    },
+    target: {
+      type: "string",
+      description: t("cli.onboard-coverage.args.target.description")
+    }
+  },
+  async run({ args }) {
+    try {
+      const projectRoot = resolve(args.target ?? process.cwd());
+      const report = runOnboardCoverage(projectRoot);
+      if (args.json === true) {
+        process.stdout.write(`${JSON.stringify(report)}
+`);
+      } else {
+        process.stdout.write(`${renderHumanReadable(report)}
+`);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`onboard-coverage failed: ${message}
+`);
+      process.exitCode = 1;
+    }
+  }
+});
+var onboard_coverage_default = onboardCoverageCommand;
+export {
+  onboard_coverage_default as default,
+  onboardCoverageCommand,
+  runOnboardCoverage
+};

package/dist/{plan-context-hint-QMUPAXIB.js → plan-context-hint-FC6P3WFE.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   resolveDevMode
-} from "./chunk-OBQU6NHO.js";
+} from "./chunk-COI5VDFU.js";
 
 // src/commands/plan-context-hint.ts
 import { defineCommand } from "citty";
@@ -10,7 +10,12 @@ var ALL_PATHS_SENTINEL = "**";
 var planContextHintCommand = defineCommand({
   meta: {
     name: "plan-context-hint",
-    description: "Emit versioned knowledge hint JSON to stdout. Used by rc.6 hooks and the fabric-import skill."
+    description: "Emit versioned knowledge hint JSON to stdout. Used by rc.6 hooks and the fabric-import skill.",
+    // rc.15 TASK-004 (C8): hidden from `fabric --help` listing. The command stays
+    // callable so hook scripts and the fabric-import skill can still invoke
+    // it via `fabric plan-context-hint ...`; it just no longer appears in the
+    // top-level usage banner alongside install/doctor/serve/uninstall/config.
+    hidden: true
   },
   args: {
     paths: {
@@ -53,27 +58,38 @@ async function runPlanContextHint(opts) {
   const result = await planContext(resolution.target, {
     paths: targetPaths
   });
-  const sharedIndex = result.shared.description_index;
-  const narrowSource = all ? sharedIndex : (
-    // Path mode: union of per-entry description_index across requested
-    // paths, deduped by stable_id. This is identical to `shared` for L0/L1
-    // entries (always included) and additionally captures L2 entries whose
-    // scope_glob matches the requested path.
-    dedupeByStableId(result.entries.flatMap((entry) => entry.description_index))
-  );
-  const narrow = narrowSource.map((item) => ({
+  const candidates = result.candidates;
+  const entries = candidates.map((item) => ({
     id: item.stable_id,
-    type: item.type ?? item.description.knowledge_type ?? "",
-    maturity: item.maturity ?? item.description.maturity ?? "",
-    summary: item.description.summary
+    type: item.description.knowledge_type ?? "",
+    maturity: item.description.maturity ?? "",
+    summary: item.description.summary,
+    relevance_scope: item.description.relevance_scope ?? "broad"
   }));
-  return {
-    version: 1,
+  let narrow_count = 0;
+  let broad_only_count = 0;
+  for (const e of entries) {
+    if (e.relevance_scope === "narrow") narrow_count += 1;
+    else broad_only_count += 1;
+  }
+  const output = {
+    version: 2,
     revision_hash: result.revision_hash,
     target_paths: targetPaths,
-    narrow,
-    broad_count: sharedIndex.length
+    entries,
+    // Legacy field — preserved for v2 consumers that haven't migrated. Value
+    // semantics unchanged from rc.18 (total candidate count).
+    broad_count: candidates.length,
+    narrow_count,
+    broad_only_count
   };
+  if (result.auto_healed === true) {
+    output.auto_healed = true;
+    if (typeof result.previous_revision_hash === "string") {
+      output.previous_revision_hash = result.previous_revision_hash;
+    }
+  }
+  return output;
 }
 function parsePathsArg(raw) {
   if (raw === void 0 || raw.length === 0) {
@@ -81,16 +97,6 @@ function parsePathsArg(raw) {
   }
   return raw.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
 }
-function dedupeByStableId(items) {
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const item of items) {
-    if (seen.has(item.stable_id)) continue;
-    seen.add(item.stable_id);
-    result.push(item);
-  }
-  return result;
-}
 export {
   plan_context_hint_default as default,
   planContextHintCommand,

package/dist/scope-explain-2F2R5URO.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import {
+  scopeExplain
+} from "./chunk-L4Q55UC4.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 result = scopeExplain(process.cwd(), args.scope);
+    if (result === null) {
+      console.log("no global Fabric config \u2014 run `fabric install --global <url>` first");
+      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-XTSE5TY6.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+import {
+  storeAdd,
+  storeBind,
+  storeExplain,
+  storeList,
+  storeRemove,
+  storeSwitchWrite
+} from "./chunk-HFQVXY6P.js";
+import {
+  regenerateBindingsSnapshot
+} from "./chunk-WU6GAPKH.js";
+import "./chunk-L4Q55UC4.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 stores = storeList();
+    if (stores.length === 0) {
+      console.log("(no stores mounted)");
+      return;
+    }
+    for (const store of stores) {
+      console.log(`${store.alias}	${store.store_uuid}	${store.remote ?? "(local-only)"}`);
+    }
+  }
+});
+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 }) {
+    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(`mounted '${args.alias}' (${next.stores.length} store(s) total)`);
+  }
+});
+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);
+    console.log(
+      detached === null ? `no store aliased '${args.alias}'` : `detached '${args.alias}' \u2014 on-disk store tree left intact (detach \u2260 delete)`
+    );
+  }
+});
+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 ? `no store aliased '${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 next = storeBind(process.cwd(), entry);
+    console.log(`bound required store '${args.id}' (${next.required_stores?.length ?? 0} required)`);
+    regenerateBindingsSnapshot(process.cwd(), { 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 }) {
+    storeSwitchWrite(process.cwd(), args.alias);
+    console.log(`active write store set to '${args.alias}' for this project`);
+  }
+});
+var store_default = defineCommand({
+  meta: { name: "store", description: "Manage mounted Fabric knowledge stores" },
+  subCommands: {
+    list: listCommand,
+    add: addCommand,
+    remove: removeCommand,
+    explain: explainCommand,
+    bind: bindCommand,
+    "switch-write": switchWriteCommand
+  }
+});
+export {
+  store_default as default
+};