@fenglimg/fabric-cli 1.6.0 → 1.8.0-rc.1

package/dist/chunk-KOAEIH72.js

@@ -1,270 +0,0 @@
-#!/usr/bin/env node
-import {
-  t
-} from "./chunk-6ICJICVU.js";
-
-// src/commands/sync-meta.ts
-import { createHash } from "crypto";
-import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "fs";
-import { isAbsolute, join, relative, resolve, sep } from "path";
-import {
-  agentsMetaSchema,
-  deriveAgentsMetaLayer,
-  deriveAgentsMetaStableId,
-  deriveAgentsMetaTopologyType
-} from "@fenglimg/fabric-shared";
-import { defineCommand } from "citty";
-var syncMetaCommand = defineCommand({
-  meta: {
-    name: "sync-meta",
-    description: t("cli.sync-meta.description")
-  },
-  args: {
-    target: {
-      type: "string",
-      description: t("cli.sync-meta.args.target.description"),
-      default: process.cwd()
-    },
-    "check-only": {
-      type: "boolean",
-      description: t("cli.sync-meta.args.check-only.description"),
-      default: false
-    }
-  },
-  async run({ args }) {
-    const target = normalizeTarget(args.target);
-    const metaPath = join(target, ".fabric", "agents.meta.json");
-    const computedMeta = computeAgentsMeta(target);
-    const existingMeta = readExistingMeta(metaPath);
-    if (args["check-only"]) {
-      if (!existingMeta || stableStringify(existingMeta) !== stableStringify(computedMeta)) {
-        writeStderr(t("cli.sync-meta.drift-detected"));
-        process.exitCode = 1;
-      }
-      return;
-    }
-    if (existingMeta && stableStringify(existingMeta) === stableStringify(computedMeta)) {
-      return;
-    }
-    mkdirSync(join(target, ".fabric"), { recursive: true });
-    writeFileSync(metaPath, `${JSON.stringify(computedMeta, null, 2)}
-`, "utf8");
-    writeStderr(t("cli.sync-meta.updated", { label: t("cli.shared.updated"), path: metaPath }));
-  }
-});
-var sync_meta_default = syncMetaCommand;
-function computeAgentsMeta(target) {
-  assertExistingDirectory(target);
-  const metaPath = join(target, ".fabric", "agents.meta.json");
-  const existingMeta = readExistingMeta(metaPath);
-  const existingByFile = indexExistingNodesByFile(existingMeta);
-  const agentsFiles = findFabricAgentsFiles(target);
-  const nodes = {};
-  const bootstrapNode = createBootstrapNode(
-    target,
-    existingByFile.get(".fabric/bootstrap/README.md")?.node ?? existingByFile.get("AGENTS.md")?.node
-  );
-  if (bootstrapNode !== void 0) {
-    nodes.L0 = bootstrapNode;
-  }
-  for (const file of agentsFiles) {
-    const existing = existingByFile.get(file);
-    const source = readFileSync(join(target, file), "utf8");
-    const id = deriveNodeId(file);
-    const hash = sha256(source);
-    const defaults = createDefaultNodeMeta(file);
-    const identity = deriveRuleIdentity(file, source, existing?.node);
-    nodes[id] = {
-      ...defaults,
-      ...existing?.node,
-      file,
-      hash,
-      stable_id: identity.stableId,
-      identity_source: identity.identitySource
-    };
-  }
-  return {
-    ...existingMeta ?? {},
-    revision: computeRevision(nodes),
-    nodes: sortNodes(nodes)
-  };
-}
-function normalizeTarget(targetInput) {
-  return isAbsolute(targetInput) ? targetInput : resolve(process.cwd(), targetInput);
-}
-function assertExistingDirectory(target) {
-  if (!existsSync(target) || !statSync(target).isDirectory()) {
-    throw new Error(t("cli.shared.target-invalid", { target }));
-  }
-}
-function readExistingMeta(metaPath) {
-  if (!existsSync(metaPath)) {
-    return void 0;
-  }
-  try {
-    return agentsMetaSchema.parse(JSON.parse(readFileSync(metaPath, "utf8")));
-  } catch {
-    return void 0;
-  }
-}
-function findFabricAgentsFiles(target) {
-  const agentsRoot = join(target, ".fabric", "agents");
-  if (!existsSync(agentsRoot) || !statSync(agentsRoot).isDirectory()) {
-    return [];
-  }
-  const files = [];
-  const stack = [agentsRoot];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    if (current === void 0) {
-      continue;
-    }
-    for (const entry of readdirSync(current, { withFileTypes: true })) {
-      const absolutePath = join(current, entry.name);
-      const relativePath = toPosixPath(relative(target, absolutePath));
-      if (entry.isDirectory()) {
-        stack.push(absolutePath);
-      } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        files.push(relativePath);
-      }
-    }
-  }
-  return files.sort();
-}
-function deriveLayer(relativePath) {
-  return deriveAgentsMetaLayer(relativePath);
-}
-function deriveTopologyType(relativePath) {
-  return deriveAgentsMetaTopologyType(relativePath);
-}
-function indexExistingNodesByFile(existingMeta) {
-  const byFile = /* @__PURE__ */ new Map();
-  for (const [id, node] of Object.entries(existingMeta?.nodes ?? {})) {
-    byFile.set(toPosixPath(node.file), { id, node });
-  }
-  return byFile;
-}
-function deriveNodeId(file) {
-  if (file === ".fabric/bootstrap/README.md") {
-    return "L0";
-  }
-  const layer = deriveLayer(file);
-  const relativeStem = getMirrorRelativeStem(file);
-  return `${layer}/${relativeStem}`;
-}
-function createDefaultNodeMeta(file) {
-  const layer = deriveLayer(file);
-  const topologyType = deriveTopologyType(file);
-  return {
-    file,
-    scope_glob: deriveScopeGlob(file),
-    deps: layer === "L0" ? [] : ["L0"],
-    priority: layer === "L0" ? "high" : "medium",
-    layer,
-    topology_type: topologyType,
-    hash: ""
-  };
-}
-function createBootstrapNode(target, existing) {
-  const bootstrapPath = join(target, ".fabric", "bootstrap", "README.md");
-  const legacyBootstrapPath = join(target, "AGENTS.md");
-  const sourcePath = existsSync(bootstrapPath) ? bootstrapPath : existsSync(legacyBootstrapPath) ? legacyBootstrapPath : void 0;
-  if (sourcePath === void 0) {
-    return void 0;
-  }
-  const hash = sha256(readFileSync(sourcePath, "utf8"));
-  const identity = {
-    stableId: existing?.stable_id ?? deriveAgentsMetaStableId(".fabric/bootstrap/README.md"),
-    identitySource: existing?.identity_source ?? "derived"
-  };
-  return {
-    ...createDefaultNodeMeta(".fabric/bootstrap/README.md"),
-    ...existing,
-    file: ".fabric/bootstrap/README.md",
-    hash,
-    stable_id: identity.stableId,
-    identity_source: identity.identitySource
-  };
-}
-function deriveScopeGlob(file) {
-  if (file === ".fabric/bootstrap/README.md") {
-    return "**";
-  }
-  const stem = getMirrorRelativeStem(file);
-  const segments = stem.split("/").filter(Boolean);
-  if (segments.length === 0 || stem === "root") {
-    return "**";
-  }
-  if (segments[0] === "_cross") {
-    return "**";
-  }
-  if (segments.at(-1) === "rules") {
-    segments.pop();
-  }
-  const scopePath = segments.join("/");
-  return scopePath === "" ? "**" : `${scopePath}/**`;
-}
-function getMirrorRelativeStem(file) {
-  return file.replace(/^\.fabric\/agents\//, "").replace(/\.md$/, "");
-}
-function sortNodes(nodes) {
-  return Object.fromEntries(Object.entries(nodes).sort(([left], [right]) => left.localeCompare(right)));
-}
-function computeRevision(nodes) {
-  const revisionSource = Object.entries(sortNodes(nodes)).map(([id, node]) => [id, node.hash, node.stable_id ?? "", node.identity_source ?? ""].join("|")).join("\n");
-  return sha256(revisionSource);
-}
-function writeStderr(message) {
-  process.stderr.write(`${message}
-`);
-}
-function stableStringify(value) {
-  return JSON.stringify(value, Object.keys(flattenKeys(value)).sort());
-}
-function flattenKeys(value, keys = {}) {
-  if (value && typeof value === "object") {
-    for (const [key, child] of Object.entries(value)) {
-      keys[key] = true;
-      flattenKeys(child, keys);
-    }
-  }
-  return keys;
-}
-function toPosixPath(path) {
-  return path.split(sep).join("/");
-}
-function sha256(content) {
-  return `sha256:${createHash("sha256").update(content).digest("hex")}`;
-}
-function deriveRuleIdentity(file, source, existing) {
-  const declaredStableId = extractDeclaredStableId(source);
-  const derivedStableId = deriveAgentsMetaStableId(file);
-  if (declaredStableId !== void 0) {
-    return {
-      stableId: declaredStableId,
-      identitySource: "declared"
-    };
-  }
-  if (existing?.identity_source === "declared" && existing.stable_id !== void 0 && existing.stable_id !== derivedStableId) {
-    return {
-      stableId: existing.stable_id,
-      identitySource: "declared"
-    };
-  }
-  return {
-    stableId: derivedStableId,
-    identitySource: "derived"
-  };
-}
-function extractDeclaredStableId(source) {
-  const match = /^(?:\uFEFF)?<!--\s*fab:rule-id\s+([A-Za-z0-9][A-Za-z0-9/_-]*)\s*-->\s*(?:\r?\n|$)/u.exec(source);
-  return match?.[1];
-}
-
-export {
-  syncMetaCommand,
-  sync_meta_default,
-  computeAgentsMeta,
-  deriveLayer,
-  deriveTopologyType
-};

package/dist/chunk-L43IGJ6X.js

@@ -1,106 +0,0 @@
-#!/usr/bin/env node
-import {
-  padEnd
-} from "./chunk-WWNXR34K.js";
-import {
-  t
-} from "./chunk-6ICJICVU.js";
-
-// src/commands/human-lint.ts
-import { createHash } from "crypto";
-import { existsSync } from "fs";
-import { readFile } from "fs/promises";
-import { isAbsolute, join, resolve } from "path";
-import { defineCommand } from "citty";
-import { humanLockEntrySchema } from "@fenglimg/fabric-shared";
-var humanLintCommand = defineCommand({
-  meta: {
-    name: "human-lint",
-    description: t("cli.human-lint.description")
-  },
-  args: {
-    target: {
-      type: "string",
-      description: t("cli.human-lint.args.target.description"),
-      default: process.cwd()
-    }
-  },
-  async run({ args }) {
-    const target = normalizeTarget(args.target);
-    const humanLockPath = join(target, ".fabric", "human-lock.json");
-    if (!existsSync(humanLockPath)) {
-      return;
-    }
-    const parsed = JSON.parse(await readFile(humanLockPath, "utf8"));
-    const locked = Array.isArray(parsed.locked) ? parsed.locked : [];
-    if (locked.length === 0) {
-      return;
-    }
-    const snapshots = await Promise.all(
-      Array.from(new Set(locked.map((entry) => entry.file))).map(async (file) => {
-        try {
-          return {
-            file,
-            content: await readFile(join(target, file), "utf8")
-          };
-        } catch {
-          return {
-            file,
-            content: null
-          };
-        }
-      })
-    );
-    const snapshotByFile = new Map(snapshots.map((snapshot) => [snapshot.file, snapshot]));
-    const violations = [];
-    for (const entry of locked) {
-      const snapshot = snapshotByFile.get(entry.file);
-      const actual = snapshot?.content === null || snapshot === void 0 ? "missing" : hashLockedContent(snapshot.content, entry);
-      if (actual !== entry.hash) {
-        violations.push({
-          location: `${entry.file}:${entry.start_line}-${entry.end_line}`,
-          expected: shortenHash(entry.hash),
-          actual: shortenHash(actual)
-        });
-      }
-    }
-    if (violations.length === 0) {
-      return;
-    }
-    writeStderr(t("cli.human-lint.drift-detected"));
-    writeStderr(
-      `${padEnd(t("cli.human-lint.table.location"), 32)} ${padEnd(t("cli.human-lint.table.expected"), 18)} ${t("cli.human-lint.table.got")}`
-    );
-    for (const violation of violations) {
-      writeStderr(
-        `${padEnd(violation.location, 32)} ${padEnd(violation.expected, 18)} ${violation.actual}`
-      );
-    }
-    process.exitCode = 1;
-  }
-});
-var human_lint_default = humanLintCommand;
-function normalizeTarget(targetInput) {
-  return isAbsolute(targetInput) ? targetInput : resolve(process.cwd(), targetInput);
-}
-function hashLockedContent(content, entry) {
-  const lines = content.split(/\r?\n/);
-  const slice = lines.slice(Math.max(entry.start_line - 1, 0), Math.max(entry.end_line, 0)).join("\n");
-  return `sha256:${createHash("sha256").update(slice).digest("hex")}`;
-}
-function shortenHash(value) {
-  if (value === "missing") {
-    return t("cli.shared.missing");
-  }
-  return value.slice(0, 15);
-}
-function writeStderr(message) {
-  process.stderr.write(`${message}
-`);
-}
-
-export {
-  humanLintCommand,
-  human_lint_default,
-  humanLockEntrySchema
-};

package/dist/chunk-T2WJF5I3.js

@@ -1,254 +0,0 @@
-#!/usr/bin/env node
-import {
-  createScanReport
-} from "./chunk-QSAEGVKE.js";
-import {
-  readFabricConfig
-} from "./chunk-AEOYCVBG.js";
-import {
-  resolveClients
-} from "./chunk-BEKSXO5N.js";
-import {
-  t
-} from "./chunk-6ICJICVU.js";
-
-// src/commands/bootstrap.ts
-import { resolve as resolve2 } from "path";
-import { defineCommand } from "citty";
-
-// src/bootstrap-guide.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { dirname, isAbsolute, join, parse, resolve } from "path";
-import { fileURLToPath } from "url";
-var AGENTS_TEMPLATE_BY_FRAMEWORK = {
-  "cocos-creator": "templates/agents-md/variants/cocos.md",
-  vite: "templates/agents-md/variants/vite.md",
-  next: "templates/agents-md/variants/next.md"
-};
-var FABRIC_GUIDE_PATH = ".fabric/bootstrap/README.md";
-async function buildFabricBootstrapGuide(target) {
-  const workspaceRoot = normalizeTarget(target);
-  const scanReport = await createScanReport(workspaceRoot);
-  const template = readFileSync(findBootstrapTemplatePath(scanReport.framework.kind), "utf8");
-  const packageName = readPackageName(workspaceRoot) ?? parse(workspaceRoot).base;
-  return ensureTrailingNewline(
-    template.replaceAll("{ projectName }", packageName).replaceAll("{ frameworkKind }", scanReport.framework.kind)
-  );
-}
-async function ensureFabricBootstrapGuide(workspaceRoot, force) {
-  const guidePath = resolve(workspaceRoot, FABRIC_GUIDE_PATH);
-  if (existsSync(guidePath) && !force) {
-    return;
-  }
-  mkdirSync(dirname(guidePath), { recursive: true });
-  writeFileSync(guidePath, await buildFabricBootstrapGuide(workspaceRoot), "utf8");
-}
-function findBootstrapTemplatePath(frameworkKind) {
-  const relativePath = AGENTS_TEMPLATE_BY_FRAMEWORK[frameworkKind] ?? "templates/agents-md/AGENTS.md.template";
-  return findTemplatePath(relativePath);
-}
-function readPackageName(target) {
-  const packageJsonPath = join(target, "package.json");
-  if (!existsSync(packageJsonPath)) {
-    return void 0;
-  }
-  try {
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-    return packageJson.name;
-  } catch {
-    return void 0;
-  }
-}
-function findTemplatePath(relativePath) {
-  const currentModuleDir = dirname(fileURLToPath(import.meta.url));
-  const candidates = [
-    ...templateCandidatesFrom(process.cwd(), relativePath),
-    ...templateCandidatesFrom(currentModuleDir, relativePath)
-  ];
-  for (const candidate of candidates) {
-    if (existsSync(candidate)) {
-      return candidate;
-    }
-  }
-  throw new Error(t("cli.shared.template-not-found", { path: relativePath }));
-}
-function templateCandidatesFrom(start, relativePath) {
-  const candidates = [];
-  let current = resolve(start);
-  while (true) {
-    candidates.push(join(current, ...relativePath.split("/")));
-    const parent = dirname(current);
-    if (parent === current || parse(current).root === current) {
-      break;
-    }
-    current = parent;
-  }
-  return candidates.reverse();
-}
-function ensureTrailingNewline(content) {
-  return content.endsWith("\n") ? content : `${content}
-`;
-}
-function normalizeTarget(targetInput) {
-  return isAbsolute(targetInput) ? targetInput : resolve(process.cwd(), targetInput);
-}
-
-// src/commands/bootstrap.ts
-var CLIENT_ALIASES = {
-  claude: "claude",
-  "claude-code": "claude",
-  claudecode: "claude",
-  claudecli: "claude",
-  claudecodecli: "claude",
-  claudedesktop: "claude",
-  claudecodedesktop: "claude",
-  cursor: "cursor",
-  windsurf: "windsurf",
-  roo: "roo",
-  "roo-code": "roo",
-  roocode: "roo",
-  gemini: "gemini",
-  "gemini-cli": "gemini",
-  geminicli: "gemini",
-  codex: "codex",
-  "codex-cli": "codex",
-  codexcli: "codex"
-};
-var bootstrapCommand = defineCommand({
-  meta: {
-    name: "bootstrap",
-    description: t("cli.bootstrap.description")
-  },
-  subCommands: {
-    install: defineCommand({
-      meta: {
-        name: "install",
-        description: t("cli.bootstrap.install.description")
-      },
-      args: {
-        clients: {
-          type: "string",
-          description: t("cli.bootstrap.install.args.clients.description")
-        }
-      },
-      async run({ args }) {
-        const workspaceRoot = process.cwd();
-        const selectedClients = parseClientFilter(args.clients);
-        const result = await installBootstrap(workspaceRoot, {
-          clients: selectedClients === null ? void 0 : Array.from(selectedClients, mapBootstrapClientToClientKind)
-        });
-        if (result.details.length === 0) {
-          process.stderr.write(
-            `${t("cli.bootstrap.install.no-targets")}
-`
-          );
-          return;
-        }
-        for (const detail of result.details) {
-          if (detail.action === "skipped") {
-            process.stderr.write(`${t("cli.bootstrap.install.skipped-header", { path: detail.path })}
-`);
-            continue;
-          }
-          if (detail.action === "prepended") {
-            process.stderr.write(`${t("cli.bootstrap.install.prepended", { path: detail.path })}
-`);
-            continue;
-          }
-          process.stderr.write(`${t("cli.bootstrap.install.installed", { path: detail.path })}
-`);
-        }
-      }
-    })
-  }
-});
-var bootstrap_default = bootstrapCommand;
-async function installBootstrap(target, options = {}) {
-  const workspaceRoot = resolve2(target);
-  const fabricConfig = readFabricConfig(workspaceRoot);
-  const targets = resolveBootstrapTargets(workspaceRoot, fabricConfig, options.clients);
-  const installed = [];
-  const skipped = [];
-  const details = [];
-  await ensureFabricBootstrapGuide(workspaceRoot, options.force);
-  for (const bootstrapTarget of targets) {
-    details.push({
-      client: bootstrapTarget.client,
-      path: resolve2(workspaceRoot, FABRIC_GUIDE_PATH),
-      action: "skipped"
-    });
-    skipped.push(bootstrapTarget.client);
-  }
-  return { installed, skipped, details };
-}
-function parseClientFilter(value) {
-  if (value === void 0 || value.trim().length === 0) {
-    return null;
-  }
-  const clients = /* @__PURE__ */ new Set();
-  for (const rawClient of value.split(",")) {
-    const alias = rawClient.trim().toLowerCase();
-    const client = CLIENT_ALIASES[alias];
-    if (client === void 0) {
-      throw new Error(t("cli.bootstrap.errors.unknown-client", { client: rawClient }));
-    }
-    clients.add(client);
-  }
-  return clients;
-}
-function resolveBootstrapTargets(workspaceRoot, fabricConfig, selectedClients) {
-  const targets = [];
-  const seenClients = /* @__PURE__ */ new Set();
-  const clientKinds = selectedClients ?? resolveClients(workspaceRoot, fabricConfig).map((writer) => writer.clientKind);
-  for (const clientKind of clientKinds) {
-    const bootstrapClient = mapClientKind(clientKind);
-    if (bootstrapClient === null || seenClients.has(bootstrapClient)) {
-      continue;
-    }
-    seenClients.add(bootstrapClient);
-    targets.push({ client: clientKind, bootstrapClient });
-  }
-  return targets;
-}
-function mapClientKind(clientKind) {
-  switch (clientKind) {
-    case "ClaudeCodeCLI":
-    case "ClaudeCodeDesktop":
-      return "claude";
-    case "Cursor":
-      return "cursor";
-    case "Windsurf":
-      return "windsurf";
-    case "RooCode":
-      return "roo";
-    case "GeminiCLI":
-      return "gemini";
-    case "CodexCLI":
-      return "codex";
-    default:
-      return null;
-  }
-}
-function mapBootstrapClientToClientKind(client) {
-  switch (client) {
-    case "claude":
-      return "ClaudeCodeCLI";
-    case "cursor":
-      return "Cursor";
-    case "windsurf":
-      return "Windsurf";
-    case "roo":
-      return "RooCode";
-    case "gemini":
-      return "GeminiCLI";
-    case "codex":
-      return "CodexCLI";
-  }
-}
-
-export {
-  buildFabricBootstrapGuide,
-  bootstrapCommand,
-  bootstrap_default,
-  installBootstrap
-};

package/dist/chunk-WWNXR34K.js

@@ -1,49 +0,0 @@
-#!/usr/bin/env node
-
-// src/colors.ts
-import pc from "picocolors";
-import stringWidth from "string-width";
-function isColorEnabled() {
-  return !process.env.NO_COLOR && Boolean(process.stdout.isTTY) && Boolean(process.stderr.isTTY);
-}
-function colorize(painter) {
-  return (value) => isColorEnabled() ? painter(value) : value;
-}
-var paint = {
-  success: colorize(pc.green),
-  warn: colorize(pc.yellow),
-  error: colorize(pc.red),
-  drift: colorize(pc.magenta),
-  ai: colorize(pc.blue),
-  human: colorize(pc.cyan),
-  muted: colorize(pc.dim)
-};
-var symbol = {
-  get ok() {
-    return isColorEnabled() ? paint.success("\u2713") : "[ok]";
-  },
-  get warn() {
-    return isColorEnabled() ? paint.warn("!") : "[warn]";
-  },
-  get error() {
-    return isColorEnabled() ? paint.error("x") : "[error]";
-  }
-};
-function displayWidth(value) {
-  return stringWidth(value);
-}
-function padEnd(value, width, char = " ") {
-  const fill = char.length > 0 ? char : " ";
-  let result = value;
-  while (displayWidth(result) < width) {
-    result += fill;
-  }
-  return result;
-}
-
-export {
-  paint,
-  symbol,
-  displayWidth,
-  padEnd
-};