@fenglimg/fabric-shared 1.7.0 → 1.8.0-rc.2

package/dist/node/atomic-write.d.ts

@@ -0,0 +1,14 @@
+interface AtomicWriteOptions {
+    fsync?: boolean;
+}
+interface AtomicWriteJsonOptions extends AtomicWriteOptions {
+    indent?: number;
+}
+declare function atomicWriteText(path: string, content: string, opts?: AtomicWriteOptions): Promise<void>;
+declare function atomicWriteJson(path: string, value: unknown, opts?: AtomicWriteJsonOptions): Promise<void>;
+interface LedgerWriteQueue {
+    append(path: string, line: string): Promise<void>;
+}
+declare function createLedgerWriteQueue(): LedgerWriteQueue;
+
+export { type AtomicWriteJsonOptions, type AtomicWriteOptions, type LedgerWriteQueue, atomicWriteJson, atomicWriteText, createLedgerWriteQueue };

package/dist/node/atomic-write.js

@@ -0,0 +1,60 @@
+// src/node/atomic-write.ts
+import { appendFile, open, rename, unlink, writeFile } from "fs/promises";
+function makeTmpSuffix() {
+  const rand = Math.floor(Math.random() * 65535).toString(16).padStart(4, "0");
+  return `.${process.pid}.${Date.now()}.${rand}.tmp`;
+}
+async function atomicWriteText(path, content, opts) {
+  const tmpPath = path + makeTmpSuffix();
+  try {
+    if (opts?.fsync) {
+      const fd = await open(tmpPath, "w");
+      try {
+        await fd.writeFile(content, "utf8");
+        await fd.datasync();
+      } finally {
+        await fd.close();
+      }
+    } else {
+      await writeFile(tmpPath, content, "utf8");
+    }
+    await rename(tmpPath, path);
+  } catch (err) {
+    try {
+      await unlink(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+}
+async function atomicWriteJson(path, value, opts) {
+  const indent = opts?.indent ?? 2;
+  const content = JSON.stringify(value, null, indent) + "\n";
+  await atomicWriteText(path, content, { fsync: opts?.fsync });
+}
+function createLedgerWriteQueue() {
+  const chains = /* @__PURE__ */ new Map();
+  async function doAppend(path, line) {
+    const normalized = line.endsWith("\n") ? line : line + "\n";
+    await appendFile(path, normalized, "utf8");
+  }
+  return {
+    append(path, line) {
+      const prev = chains.get(path) ?? Promise.resolve();
+      const next = prev.catch(() => void 0).then(() => doAppend(path, line));
+      chains.set(path, next);
+      const guarded = next.catch(() => void 0);
+      guarded.finally(() => {
+        if (chains.get(path) === next) {
+          chains.delete(path);
+        }
+      });
+      return next;
+    }
+  };
+}
+export {
+  atomicWriteJson,
+  atomicWriteText,
+  createLedgerWriteQueue
+};

package/dist/node/bootstrap-guide.d.ts

@@ -0,0 +1,12 @@
+declare const FABRIC_BOOTSTRAP_PATH = ".fabric/bootstrap/README.md";
+/**
+ * Build the content for .fabric/bootstrap/README.md.
+ *
+ * Produces the same structured bootstrap guide that `fab init` writes, using
+ * the detected framework kind and the project name from package.json.  This
+ * lives in shared so both the CLI and the server doctor --fix path can use the
+ * identical builder.
+ */
+declare function buildBootstrapContent(projectRoot: string): string;
+
+export { FABRIC_BOOTSTRAP_PATH, buildBootstrapContent };

package/dist/node/bootstrap-guide.js

@@ -0,0 +1,52 @@
+import {
+  detectFramework
+} from "../chunk-GI6L6VTT.js";
+
+// src/node/bootstrap-guide.ts
+import { existsSync, readFileSync } from "fs";
+import { join, parse } from "path";
+var FABRIC_BOOTSTRAP_PATH = ".fabric/bootstrap/README.md";
+function buildBootstrapContent(projectRoot) {
+  const framework = detectFramework(projectRoot);
+  const projectName = readProjectName(projectRoot) ?? parse(projectRoot).base;
+  const frameworkKind = framework.kind;
+  const content = `# ${projectName} \u2014 Fabric Bootstrap Protocol
+
+## CORE RULES (DO NOT TRANSLATE)
+
+MUST: Treat this file as the Fabric Protocol bootstrap for this repository.
+MUST: Treat \`.fabric/rules/\` as the source of truth for all Fabric rule bodies.
+MUST: Before ANY code reading, architecture planning, or logic modification, call \`fab_plan_context(paths=[<target file>])\`, then call \`fab_get_rule_sections\`.
+MUST: When creating or changing an L1/L2 rule node, keep \`.fabric/agents.meta.json\` synchronized through Fabric tooling.
+MUST: Preserve protected tokens exactly: \`AGENTS.md\`, \`.fabric/rules/\`, \`.fabric/agents.meta.json\`, \`fab_plan_context\`, \`fab_get_rule_sections\`, \`rule sources\`, \`rule source mirroring\`, \`MUST\`, \`NEVER\`.
+NEVER: Add import-style directive lines to this bootstrap file.
+NEVER: Put framework, domain, repository rule bodies, or submodule rules in this file.
+NEVER: Create colocated \`AGENTS.md\` rule files under source directories.
+
+## Usage
+
+- This file bootstraps the Fabric Protocol; it does not carry project-specific rules.
+- Detailed bootstrap notes are in \`.fabric/bootstrap/README.md\`.
+- Detected framework kind: \`${frameworkKind}\`.
+- This repository uses \`rule source mirroring\`: source directories contain ZERO rule files, while \`.fabric/rules/\` mirrors source paths for AI constraints.
+- Root-level rules belong in \`.fabric/rules/root.md\`; cross-domain rules in \`.fabric/rules/_cross/\`.
+- If \`.fabric/rules/root.md\` is missing, complete the Fabric initialization flow before normal coding.
+`;
+  return content;
+}
+function readProjectName(projectRoot) {
+  const packageJsonPath = join(projectRoot, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return void 0;
+  }
+  try {
+    const raw = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    return typeof raw.name === "string" && raw.name.length > 0 ? raw.name : void 0;
+  } catch {
+    return void 0;
+  }
+}
+export {
+  FABRIC_BOOTSTRAP_PATH,
+  buildBootstrapContent
+};

package/dist/node/mcp-payload-guard.d.ts

@@ -0,0 +1,16 @@
+interface PayloadGuardOptions {
+    warnBytes?: number;
+    hardBytes?: number;
+}
+interface PayloadGuardResult {
+    bytes: number;
+    warning?: {
+        code: 'mcp_payload_warn';
+        message: string;
+        bytes: number;
+        threshold: number;
+    };
+}
+declare function enforcePayloadLimit(serializedPayload: string, opts?: PayloadGuardOptions): PayloadGuardResult;
+
+export { type PayloadGuardOptions, type PayloadGuardResult, enforcePayloadLimit };

package/dist/node/mcp-payload-guard.js

@@ -0,0 +1,40 @@
+import {
+  MCPError
+} from "../chunk-3SZRB42B.js";
+
+// src/node/mcp-payload-guard.ts
+var McpPayloadTooLargeError = class extends MCPError {
+  code = "MCP_PAYLOAD_TOO_LARGE";
+  httpStatus = 413;
+};
+var DEFAULT_WARN = 16384;
+var DEFAULT_HARD = 65536;
+function enforcePayloadLimit(serializedPayload, opts) {
+  const warnAt = opts?.warnBytes ?? DEFAULT_WARN;
+  const hardAt = opts?.hardBytes ?? DEFAULT_HARD;
+  const bytes = Buffer.byteLength(serializedPayload, "utf8");
+  if (bytes > hardAt) {
+    throw new McpPayloadTooLargeError(
+      `MCP payload ${bytes} bytes exceeds hard limit ${hardAt}`,
+      {
+        actionHint: `Reduce response size or increase fabric.config.json mcpPayloadLimits.hardBytes`,
+        details: { bytes, threshold: hardAt }
+      }
+    );
+  }
+  if (bytes > warnAt) {
+    return {
+      bytes,
+      warning: {
+        code: "mcp_payload_warn",
+        message: `Payload ${bytes}B exceeds warning threshold ${warnAt}B`,
+        bytes,
+        threshold: warnAt
+      }
+    };
+  }
+  return { bytes };
+}
+export {
+  enforcePayloadLimit
+};

package/dist/node.js

@@ -1,175 +1,6 @@
-// src/detector.ts
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
-function detectFramework(root) {
-  const evidence = [];
-  const creatorConfigPath = join(root, "project.config.json");
-  if (existsSync(creatorConfigPath)) {
-    const version = readCreatorVersion(creatorConfigPath);
-    return {
-      kind: "cocos-creator",
-      version,
-      subkind: inferCocosSubkind(root, version),
-      evidence: version === "unknown" ? ["project.config.json"] : [`project.config.json: creator.version=${version}`],
-      framework: "cocos-creator",
-      confidence: "HIGH",
-      ast_evidence: [],
-      co_packages: collectProjectFileEvidence(root, ["package.json", "tsconfig.json"])
-    };
-  }
-  const packageJsonPath = join(root, "package.json");
-  if (existsSync(packageJsonPath)) {
-    const packageJson = readPackageJson(packageJsonPath);
-    const creatorVersion = packageJson.creator?.version;
-    if (typeof creatorVersion === "string" && creatorVersion.trim().length > 0) {
-      const deps2 = collectDependencyVersions(packageJson);
-      return {
-        kind: "cocos-creator",
-        version: creatorVersion,
-        subkind: inferCocosSubkind(root, creatorVersion),
-        evidence: [`package.json: creator.version=${creatorVersion}`],
-        framework: "cocos-creator",
-        confidence: "HIGH",
-        ast_evidence: [],
-        co_packages: collectCoPackages(deps2, "cocos-creator", root)
-      };
-    }
-    const deps = collectDependencyVersions(packageJson);
-    for (const [dependencyName, kind] of [
-      ["next", "next"],
-      ["vite", "vite"],
-      ["react", "react"],
-      ["vue", "vue"]
-    ]) {
-      if (deps.has(dependencyName)) {
-        const version = deps.get(dependencyName) ?? "unknown";
-        evidence.push(`package.json dependency: ${dependencyName}@${version}`);
-        return {
-          kind,
-          version,
-          subkind: inferPackageSubkind(kind),
-          evidence,
-          framework: kind,
-          confidence: determinePackageConfidence(kind, deps, root),
-          ast_evidence: [],
-          co_packages: collectCoPackages(deps, kind, root)
-        };
-      }
-    }
-    evidence.push("package.json");
-  }
-  if (existsSync(join(root, "Cargo.toml"))) {
-    return {
-      kind: "rust",
-      version: "unknown",
-      subkind: "cargo-project",
-      evidence: ["Cargo.toml"],
-      framework: "rust",
-      confidence: "HIGH",
-      ast_evidence: [],
-      co_packages: collectProjectFileEvidence(root, ["Cargo.lock"])
-    };
-  }
-  if (existsSync(join(root, "pyproject.toml"))) {
-    return {
-      kind: "python",
-      version: "unknown",
-      subkind: "pyproject",
-      evidence: ["pyproject.toml"],
-      framework: "python",
-      confidence: "HIGH",
-      ast_evidence: [],
-      co_packages: collectProjectFileEvidence(root, ["uv.lock", "poetry.lock", "requirements.txt"])
-    };
-  }
-  return {
-    kind: "unknown",
-    version: "unknown",
-    subkind: "unknown",
-    evidence,
-    framework: "unknown",
-    confidence: "LOW",
-    ast_evidence: [],
-    co_packages: []
-  };
-}
-function readPackageJson(packageJsonPath) {
-  try {
-    return JSON.parse(readFileSync(packageJsonPath, "utf8"));
-  } catch {
-    return {};
-  }
-}
-function readCreatorVersion(creatorConfigPath) {
-  try {
-    const creatorConfig = JSON.parse(readFileSync(creatorConfigPath, "utf8"));
-    return creatorConfig.creator?.version ?? "unknown";
-  } catch {
-    return "unknown";
-  }
-}
-function collectDependencyVersions(packageJson) {
-  return new Map([
-    ...Object.entries(packageJson.dependencies ?? {}),
-    ...Object.entries(packageJson.devDependencies ?? {}),
-    ...Object.entries(packageJson.peerDependencies ?? {}),
-    ...Object.entries(packageJson.optionalDependencies ?? {})
-  ]);
-}
-function inferCocosSubkind(root, version) {
-  const majorVersion = Number.parseInt(version.split(".")[0] ?? "", 10);
-  if (majorVersion === 2) {
-    return "javascript-traditional";
-  }
-  if (majorVersion >= 3) {
-    return "typescript-component";
-  }
-  return existsSync(join(root, "tsconfig.json")) ? "typescript-component" : "javascript-traditional";
-}
-function inferPackageSubkind(kind) {
-  switch (kind) {
-    case "next":
-      return "next-application";
-    case "vite":
-      return "vite-application";
-    case "react":
-      return "react-application";
-    case "vue":
-      return "vue-application";
-    default:
-      return "unknown";
-  }
-}
-function determinePackageConfidence(kind, deps, root) {
-  const coPackages = collectCoPackages(deps, kind, root);
-  return coPackages.length > 0 ? "HIGH" : "MEDIUM";
-}
-function collectCoPackages(deps, kind, root) {
-  const expectedPackagesByFramework = {
-    next: ["react", "react-dom", "typescript"],
-    vite: ["@vitejs/plugin-react", "@vitejs/plugin-vue", "typescript", "react", "vue"],
-    react: ["react-dom", "@types/react", "@types/react-dom"],
-    vue: ["@vitejs/plugin-vue", "typescript"],
-    "cocos-creator": ["typescript"]
-  };
-  const expectedProjectFilesByFramework = {
-    next: ["next.config.js", "next.config.mjs", "next.config.ts", "tsconfig.json"],
-    vite: ["vite.config.js", "vite.config.mjs", "vite.config.ts", "tsconfig.json"],
-    react: ["tsconfig.json"],
-    vue: ["vue.config.js", "vite.config.ts", "tsconfig.json"],
-    "cocos-creator": ["project.config.json", "tsconfig.json"]
-  };
-  return [
-    ...compactStrings((expectedPackagesByFramework[kind] ?? []).map((packageName) => deps.has(packageName) ? packageName : null)),
-    ...collectProjectFileEvidence(root, expectedProjectFilesByFramework[kind] ?? [])
-  ];
-}
-function collectProjectFileEvidence(root, relativePaths) {
-  return relativePaths.filter((relativePath) => existsSync(join(root, relativePath)));
-}
-function compactStrings(values) {
-  return [...new Set(values.filter((value) => value !== null && value !== void 0 && value.length > 0))];
-}
+import {
+  detectFramework
+} from "./chunk-GI6L6VTT.js";
 export {
   detectFramework
 };