@fenglimg/fabric-server 0.1.0 → 1.0.0

package/dist/chunk-KZO24GUQ.js

@@ -0,0 +1,199 @@
+// src/meta-reader.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+import { agentsMetaSchema } from "@fenglimg/fabric-shared";
+import { agentsMetaNodeSchema, agentsMetaSchema as agentsMetaSchema2 } from "@fenglimg/fabric-shared";
+var AgentsMetaFileMissingError = class extends Error {
+  constructor(metaPath) {
+    super(`Fabric agents metadata file is missing: ${metaPath}`);
+    this.metaPath = metaPath;
+    this.name = "AgentsMetaFileMissingError";
+  }
+  metaPath;
+  code = "FABRIC_META_MISSING";
+};
+var AgentsMetaInvalidError = class extends Error {
+  constructor(metaPath, cause) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    super(`Fabric agents metadata file is invalid: ${metaPath}. ${detail}`);
+    this.metaPath = metaPath;
+    this.name = "AgentsMetaInvalidError";
+  }
+  metaPath;
+  code = "FABRIC_META_INVALID";
+};
+function getAgentsMetaPath(projectRoot) {
+  return join(projectRoot, ".fabric", "agents.meta.json");
+}
+function resolveProjectRoot() {
+  return process.env.FABRIC_PROJECT_ROOT ?? process.cwd();
+}
+function readAgentsMeta(projectRoot) {
+  const metaPath = getAgentsMetaPath(projectRoot);
+  let raw;
+  try {
+    raw = readFileSync(metaPath, "utf8");
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      throw new AgentsMetaFileMissingError(metaPath);
+    }
+    throw error;
+  }
+  try {
+    return agentsMetaSchema.parse(JSON.parse(raw));
+  } catch (error) {
+    throw new AgentsMetaInvalidError(metaPath, error);
+  }
+}
+
+// src/services/read-ledger.ts
+import { randomUUID } from "crypto";
+import { appendFile, readFile } from "fs/promises";
+import { join as join2 } from "path";
+import { ledgerEntrySchema } from "@fenglimg/fabric-shared";
+
+// src/services/_shared.ts
+import { resolve, sep } from "path";
+import { createHash } from "crypto";
+import { rename, writeFile } from "fs/promises";
+var FABRIC_DIR = ".fabric";
+var HUMAN_LOCK_FILE = "human-lock.json";
+var LEDGER_FILE = ".intent-ledger.jsonl";
+async function atomicWriteText(path, content) {
+  const tempPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(tempPath, content, "utf8");
+  await rename(tempPath, path);
+}
+function sha256(content) {
+  return `sha256:${createHash("sha256").update(content).digest("hex")}`;
+}
+function isNodeError(error) {
+  return error instanceof Error;
+}
+function assertPathWithinProjectRoot(projectRoot, file) {
+  const normalizedProjectRoot = resolve(projectRoot);
+  const absolutePath = resolve(normalizedProjectRoot, file);
+  const rootPrefix = normalizedProjectRoot.endsWith(sep) ? normalizedProjectRoot : `${normalizedProjectRoot}${sep}`;
+  if (!absolutePath.startsWith(rootPrefix)) {
+    throw new Error(`Path escapes project root: ${file}`);
+  }
+  return absolutePath;
+}
+
+// src/services/read-ledger.ts
+async function readLedger(projectRoot, options = {}) {
+  const ledgerPath = join2(projectRoot, LEDGER_FILE);
+  let raw;
+  try {
+    raw = await readFile(ledgerPath, "utf8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+  return raw.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0).map((line, index) => parseLedgerLine(line, index)).filter((entry) => entry !== null).filter((entry) => options.source === void 0 || entry.source === options.source).filter((entry) => options.since === void 0 || entry.ts >= options.since);
+}
+async function appendLedgerEntry(projectRoot, entry) {
+  const ledgerPath = join2(projectRoot, LEDGER_FILE);
+  const nextEntry = ledgerEntrySchema.parse({
+    ...entry,
+    id: entry.id ?? `ledger:${randomUUID()}`
+  });
+  await appendFile(ledgerPath, `${JSON.stringify(nextEntry)}
+`, "utf8");
+  return nextEntry;
+}
+function parseLedgerLine(line, index) {
+  try {
+    const parsed = JSON.parse(line);
+    if (parsed.kind === "mcp-event") {
+      return null;
+    }
+    const result = ledgerEntrySchema.safeParse(parsed);
+    if (!result.success) {
+      return null;
+    }
+    return {
+      ...result.data,
+      id: result.data.id ?? createDerivedId(index, line)
+    };
+  } catch {
+    return null;
+  }
+}
+function createDerivedId(index, line) {
+  return `ledger:${index + 1}:${sha256(line).slice("sha256:".length)}`;
+}
+
+// src/services/read-human-lock.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join3 } from "path";
+import { humanLockEntrySchema } from "@fenglimg/fabric-shared";
+async function readHumanLock(projectRoot) {
+  const document = await readHumanLockDocument(projectRoot);
+  return await Promise.all(
+    document.locked.map(async (entry) => {
+      const currentHash = await hashHumanLockedContent(projectRoot, entry);
+      return {
+        ...entry,
+        drift: currentHash !== entry.hash,
+        current_hash: currentHash
+      };
+    })
+  );
+}
+async function readHumanLockEntry(projectRoot, file) {
+  const entries = await readHumanLock(projectRoot);
+  return entries.find((entry) => entry.file === file) ?? null;
+}
+async function readHumanLockDocument(projectRoot) {
+  const humanLockPath = join3(projectRoot, FABRIC_DIR, HUMAN_LOCK_FILE);
+  const raw = await readFile2(humanLockPath, "utf8");
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Fabric human lock file is invalid: ${humanLockPath}`);
+  }
+  const rawObject = parsed;
+  const lockedResult = humanLockEntrySchema.array().safeParse(rawObject.locked ?? []);
+  if (!lockedResult.success) {
+    throw new Error(`Fabric human lock file is invalid: ${humanLockPath}`);
+  }
+  return {
+    path: humanLockPath,
+    rawObject,
+    locked: lockedResult.data
+  };
+}
+async function hashHumanLockedContent(projectRoot, entry) {
+  const targetPath = assertPathWithinProjectRoot(projectRoot, entry.file);
+  let content;
+  try {
+    content = await readFile2(targetPath, "utf8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return "missing";
+    }
+    throw error;
+  }
+  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(slice);
+}
+
+export {
+  AgentsMetaFileMissingError,
+  AgentsMetaInvalidError,
+  resolveProjectRoot,
+  readAgentsMeta,
+  FABRIC_DIR,
+  atomicWriteText,
+  sha256,
+  assertPathWithinProjectRoot,
+  readLedger,
+  appendLedgerEntry,
+  readHumanLock,
+  readHumanLockEntry,
+  readHumanLockDocument,
+  hashHumanLockedContent
+};