@fenglimg/fabric-shared 1.0.0

package/dist/index.js

@@ -0,0 +1,401 @@
+import {
+  PROTECTED_TOKENS,
+  createTranslator,
+  defaultMessages,
+  detectNodeLocale,
+  enMessages,
+  normalizeLocale,
+  zhCNMessages
+} from "./chunk-2MXNG23L.js";
+import "./chunk-LXNCAKJZ.js";
+
+// src/schemas/agents-meta.ts
+import { z } from "zod";
+var agentsMetaNodeSchema = z.object({
+  file: z.string(),
+  scope_glob: z.string(),
+  deps: z.array(z.string()),
+  priority: z.enum(["high", "medium", "low"]),
+  hash: z.string()
+});
+var agentsMetaSchema = z.object({
+  revision: z.string(),
+  nodes: z.record(agentsMetaNodeSchema)
+});
+
+// src/schemas/api-contracts.ts
+import { z as z2 } from "zod";
+var ledgerSourceSchema = z2.enum(["ai", "human"]);
+var timestampFilterSchema = z2.preprocess((value) => {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+      return void 0;
+    }
+    if (/^\d+$/.test(trimmed)) {
+      return Number.parseInt(trimmed, 10);
+    }
+    const parsed = Date.parse(trimmed);
+    return Number.isNaN(parsed) ? value : parsed;
+  }
+  return value;
+}, z2.number().int().nonnegative());
+var ledgerQuerySchema = z2.object({
+  source: ledgerSourceSchema.optional(),
+  since: timestampFilterSchema.optional()
+});
+var historyStateQuerySchema = z2.object({
+  ledger_id: z2.string().trim().min(1).optional(),
+  ts: timestampFilterSchema.optional()
+}).superRefine((value, ctx) => {
+  const provided = [value.ledger_id, value.ts].filter((entry) => entry !== void 0);
+  if (provided.length !== 1) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: "Provide exactly one of ledger_id or ts.",
+      path: ["ledger_id"]
+    });
+  }
+});
+var humanLockApproveRequestSchema = z2.object({
+  file: z2.string().min(1),
+  start_line: z2.number().int().positive(),
+  end_line: z2.number().int().positive(),
+  new_hash: z2.string().min(1)
+});
+var humanLockFileParamsSchema = z2.object({
+  file: z2.string().min(1)
+});
+var annotateIntentRequestSchema = z2.object({
+  ledger_entry_id: z2.string().min(1),
+  annotation: z2.string().trim().min(1)
+});
+
+// src/schemas/ledger-entry.ts
+import { z as z3 } from "zod";
+var ledgerEntryBaseSchema = {
+  id: z3.string().optional(),
+  ts: z3.number().int().nonnegative(),
+  intent: z3.string(),
+  affected_paths: z3.array(z3.string())
+};
+var aiLedgerEntrySchema = z3.object({
+  ...ledgerEntryBaseSchema,
+  source: z3.literal("ai"),
+  commit_sha: z3.string().optional()
+});
+var humanLedgerEntrySchema = z3.object({
+  ...ledgerEntryBaseSchema,
+  source: z3.literal("human"),
+  parent_sha: z3.string(),
+  parent_ledger_entry_id: z3.string().optional(),
+  diff_stat: z3.string(),
+  annotation: z3.string().optional()
+});
+var ledgerEntryUnionSchema = z3.discriminatedUnion("source", [aiLedgerEntrySchema, humanLedgerEntrySchema]);
+var ledgerEntrySchema = z3.preprocess((value) => {
+  if (value && typeof value === "object" && !Array.isArray(value) && (!("source" in value) || value.source === void 0)) {
+    return {
+      ...value,
+      source: "human"
+    };
+  }
+  return value;
+}, ledgerEntryUnionSchema);
+
+// src/schemas/human-lock.ts
+import { z as z4 } from "zod";
+var humanLockEntrySchema = z4.object({
+  file: z4.string(),
+  start_line: z4.number().int().nonnegative(),
+  end_line: z4.number().int().nonnegative(),
+  hash: z4.string()
+});
+var humanLockFileSchema = z4.object({
+  locked: z4.array(humanLockEntrySchema).optional()
+});
+
+// src/schemas/fabric-config.ts
+import { z as z5 } from "zod";
+var clientPathsSchema = z5.object({
+  claudeCodeCLI: z5.string().optional(),
+  claudeCodeDesktop: z5.string().optional(),
+  cursor: z5.string().optional(),
+  windsurf: z5.string().optional(),
+  rooCode: z5.string().optional(),
+  geminiCLI: z5.string().optional(),
+  codexCLI: z5.string().optional()
+});
+var fabricConfigSchema = z5.object({
+  clientPaths: clientPathsSchema.optional(),
+  externalFixturePath: z5.string().optional(),
+  scanIgnores: z5.array(z5.string()).optional()
+});
+
+// src/schemas/forensic-report.ts
+import { z as z6 } from "zod";
+var forensicCodeSampleSchema = z6.object({
+  path: z6.string(),
+  lines: z6.string(),
+  snippet: z6.string(),
+  pattern_hint: z6.string()
+});
+var forensicTopologySchema = z6.object({
+  total_files: z6.number().int().nonnegative(),
+  by_ext: z6.record(z6.number().int().nonnegative()),
+  key_dirs: z6.array(z6.string()),
+  max_depth: z6.number().int().nonnegative()
+});
+var forensicEntryPointSchema = z6.object({
+  path: z6.string(),
+  reason: z6.string(),
+  size_bytes: z6.number().int().nonnegative().optional()
+});
+var forensicFrameworkSchema = z6.object({
+  kind: z6.string(),
+  version: z6.string(),
+  subkind: z6.string(),
+  evidence: z6.array(z6.string())
+});
+var forensicReadmeSchema = z6.object({
+  quality: z6.enum(["missing", "stub", "ok"]),
+  line_count: z6.number().int().nonnegative(),
+  has_contributing: z6.boolean()
+});
+var forensicReportSchema = z6.object({
+  version: z6.string(),
+  generated_at: z6.string(),
+  generated_by: z6.string(),
+  target: z6.string(),
+  project_name: z6.string(),
+  framework: forensicFrameworkSchema,
+  topology: forensicTopologySchema,
+  entry_points: z6.array(forensicEntryPointSchema),
+  code_samples: z6.array(forensicCodeSampleSchema),
+  readme: forensicReadmeSchema,
+  recommendations_for_skill: z6.array(z6.string())
+});
+
+// src/schemas/init-context.ts
+import { z as z7 } from "zod";
+var initContextFrameworkSchema = z7.object({
+  kind: z7.string(),
+  version: z7.string(),
+  subkind: z7.string()
+});
+var initContextInvariantSchema = z7.object({
+  type: z7.enum(["ban", "require", "protect"]),
+  rule: z7.string(),
+  rationale: z7.string().optional()
+});
+var initContextDomainGroupSchema = z7.object({
+  name: z7.string(),
+  paths: z7.array(z7.string()),
+  summary: z7.string().optional()
+});
+var initContextInterviewTrailEntrySchema = z7.object({
+  phase: z7.string(),
+  question: z7.string(),
+  answer: z7.string()
+});
+var initContextSchema = z7.object({
+  framework: initContextFrameworkSchema,
+  architecture_patterns: z7.array(z7.string()),
+  invariants: z7.array(initContextInvariantSchema),
+  domain_groups: z7.array(initContextDomainGroupSchema),
+  interview_trail: z7.array(initContextInterviewTrailEntrySchema),
+  forensic_ref: z7.string()
+});
+
+// src/schemas/events.ts
+import { z as z8 } from "zod";
+var metaUpdatedEventSchema = z8.object({
+  type: z8.literal("meta:updated"),
+  payload: agentsMetaSchema
+});
+var lockDriftEventSchema = z8.object({
+  type: z8.literal("lock:drift"),
+  payload: z8.object({
+    locked: z8.array(humanLockEntrySchema),
+    drifted: z8.array(humanLockEntrySchema)
+  })
+});
+var lockApprovedEventSchema = z8.object({
+  type: z8.literal("lock:approved"),
+  payload: z8.object({
+    locked: z8.array(humanLockEntrySchema),
+    approved: z8.array(humanLockEntrySchema)
+  })
+});
+var ledgerAppendedEventSchema = z8.object({
+  type: z8.literal("ledger:appended"),
+  payload: ledgerEntrySchema
+});
+var driftDetectedEventSchema = z8.object({
+  type: z8.literal("drift:detected"),
+  payload: forensicReportSchema
+});
+var fabricEventSchema = z8.discriminatedUnion("type", [
+  metaUpdatedEventSchema,
+  lockDriftEventSchema,
+  lockApprovedEventSchema,
+  ledgerAppendedEventSchema,
+  driftDetectedEventSchema
+]);
+
+// 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}`]
+    };
+  }
+  const packageJsonPath = join(root, "package.json");
+  if (existsSync(packageJsonPath)) {
+    const packageJson = readPackageJson(packageJsonPath);
+    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
+        };
+      }
+    }
+    evidence.push("package.json");
+  }
+  if (existsSync(join(root, "Cargo.toml"))) {
+    return {
+      kind: "rust",
+      version: "unknown",
+      subkind: "cargo-project",
+      evidence: ["Cargo.toml"]
+    };
+  }
+  if (existsSync(join(root, "pyproject.toml"))) {
+    return {
+      kind: "python",
+      version: "unknown",
+      subkind: "pyproject",
+      evidence: ["pyproject.toml"]
+    };
+  }
+  return {
+    kind: "unknown",
+    version: "unknown",
+    subkind: "unknown",
+    evidence
+  };
+}
+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";
+  }
+}
+export {
+  PROTECTED_TOKENS,
+  agentsMetaNodeSchema,
+  agentsMetaSchema,
+  aiLedgerEntrySchema,
+  annotateIntentRequestSchema,
+  clientPathsSchema,
+  createTranslator,
+  defaultMessages,
+  detectFramework,
+  detectNodeLocale,
+  driftDetectedEventSchema,
+  enMessages,
+  fabricConfigSchema,
+  fabricEventSchema,
+  forensicCodeSampleSchema,
+  forensicEntryPointSchema,
+  forensicFrameworkSchema,
+  forensicReadmeSchema,
+  forensicReportSchema,
+  forensicTopologySchema,
+  historyStateQuerySchema,
+  humanLedgerEntrySchema,
+  humanLockApproveRequestSchema,
+  humanLockEntrySchema,
+  humanLockFileParamsSchema,
+  humanLockFileSchema,
+  initContextDomainGroupSchema,
+  initContextFrameworkSchema,
+  initContextInterviewTrailEntrySchema,
+  initContextInvariantSchema,
+  initContextSchema,
+  ledgerAppendedEventSchema,
+  ledgerEntrySchema,
+  ledgerQuerySchema,
+  ledgerSourceSchema,
+  lockApprovedEventSchema,
+  lockDriftEventSchema,
+  metaUpdatedEventSchema,
+  normalizeLocale,
+  zhCNMessages
+};

package/dist/types/index.d.ts

@@ -0,0 +1,55 @@
+interface AgentsMetaNode {
+    file: string;
+    scope_glob: string;
+    deps: string[];
+    priority: "high" | "medium" | "low";
+    hash: string;
+}
+interface AgentsMeta {
+    revision: string;
+    nodes: Record<string, AgentsMetaNode>;
+}
+
+interface AiLedgerEntry {
+    id?: string;
+    ts: number;
+    source: "ai";
+    commit_sha?: string;
+    intent: string;
+    affected_paths: string[];
+}
+interface HumanLedgerEntry {
+    id?: string;
+    ts: number;
+    source: "human";
+    parent_sha: string;
+    parent_ledger_entry_id?: string;
+    intent: string;
+    affected_paths: string[];
+    diff_stat: string;
+    annotation?: string;
+}
+type LedgerEntry = AiLedgerEntry | HumanLedgerEntry;
+interface HumanLockEntry {
+    file: string;
+    start_line: number;
+    end_line: number;
+    hash: string;
+}
+
+interface ClientPaths {
+    claudeCodeCLI?: string;
+    claudeCodeDesktop?: string;
+    cursor?: string;
+    windsurf?: string;
+    rooCode?: string;
+    geminiCLI?: string;
+    codexCLI?: string;
+}
+interface FabricConfig {
+    clientPaths?: ClientPaths;
+    externalFixturePath?: string;
+    scanIgnores?: string[];
+}
+
+export type { AgentsMeta, AgentsMetaNode, AiLedgerEntry, ClientPaths, FabricConfig, HumanLedgerEntry, HumanLockEntry, LedgerEntry };

package/dist/types/index.js

@@ -0,0 +1 @@
+import "../chunk-LXNCAKJZ.js";

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@fenglimg/fabric-shared",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./i18n": {
+      "types": "./dist/i18n/index.d.ts",
+      "import": "./dist/i18n/index.js"
+    },
+    "./types": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/types/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/i18n/index.ts src/types/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts src/i18n/index.ts src/types/index.ts --format esm --dts --watch"
+  }
+}