@iowarp/clio-coder 0.3.1 → 0.3.3

package/dist/{chunk-BSU2YIWB.js → chunk-MVVUPGPW.js}

@@ -1,13 +1,12 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
-  WORKSPACE_EXCLUDED_DIRS,
-  createSlicer,
-  enumerateWorkspaceFiles,
-  enumerateWorkspaceFilesAsync,
-  isIndexablePath,
+  codewikiPath,
   readCodewiki,
-  readCodewikiAsync
-} from "./chunk-N6F52NLF.js";
+  writeCodewiki
+} from "./chunk-LBMZMYH2.js";
+import {
+  withStateFileLock
+} from "./chunk-IKCO5N3L.js";
 import {
   safeResourceWrite
 } from "./chunk-WEPFGWHJ.js";
@@ -15,141 +14,137 @@ import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
 
-// src/domains/context/fingerprint.ts
+// src/domains/context/codewiki/coordinator.ts
 init_esm_shims();
-import { execFile, execFileSync } from "node:child_process";
-import { createHash } from "node:crypto";
-import { readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
-import { promisify } from "node:util";
-var execFileAsync = promisify(execFile);
-var DEFAULT_FINGERPRINT_CACHE_TTL_MS = 5e3;
-var cachedFingerprints = /* @__PURE__ */ new Map();
-var LOC_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".ts",
-  ".tsx",
-  ".js",
-  ".mjs",
-  ".cjs",
-  ".py",
-  ".rs",
-  ".go",
-  ".cc",
-  ".cpp",
-  ".cxx",
-  ".hpp",
-  ".hh",
-  ".hxx",
-  ".c",
-  ".h",
-  ".cu",
-  ".cuh",
-  ".java",
-  ".kt"
-]);
-function extensionOf(name) {
-  const index = name.lastIndexOf(".");
-  return index === -1 ? "" : name.slice(index);
-}
-function currentGitHead(cwd) {
-  try {
-    return execFileSync("git", ["rev-parse", "--verify", "HEAD"], {
-      cwd,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    }).trim();
-  } catch {
-    return null;
-  }
-}
-async function currentGitHeadAsync(cwd) {
-  try {
-    const { stdout } = await execFileAsync("git", ["rev-parse", "--verify", "HEAD"], { cwd, encoding: "utf8" });
-    return stdout.trim();
-  } catch {
-    return null;
-  }
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { Worker } from "node:worker_threads";
+var BUILD_TIMEOUT_MS = 12e4;
+var workspaceTails = /* @__PURE__ */ new Map();
+var require2 = createRequire(import.meta.url);
+function buildWorkerUrl() {
+  if (!import.meta.url.endsWith(".ts")) return new URL("./codewiki/build-worker.js", import.meta.url);
+  const loaderApi = pathToFileURL(require2.resolve("tsx/esm/api")).href;
+  const source = new URL("./build-worker.ts", import.meta.url).href;
+  return new URL(
+    `data:text/javascript,${encodeURIComponent(`const { tsImport } = await import(${JSON.stringify(loaderApi)}); await tsImport(${JSON.stringify(source)}, import.meta.url);`)}`
+  );
 }
-function countLines(filePath) {
+async function executeInWorker(request) {
+  const worker = new Worker(buildWorkerUrl(), { workerData: request, execArgv: [] });
+  let exited = false;
+  const exit = new Promise((resolve2) => {
+    worker.once("exit", () => {
+      exited = true;
+      resolve2();
+    });
+  });
+  let timer;
   try {
-    const text = readFileSync(filePath, "utf8");
-    if (text.length === 0) return 0;
-    let lines = 1;
-    for (const ch of text) {
-      if (ch === "\n") lines += 1;
+    return await new Promise((resolve2, reject) => {
+      let settled = false;
+      const finish = (callback) => {
+        if (settled) return;
+        settled = true;
+        if (timer) clearTimeout(timer);
+        callback();
+      };
+      timer = setTimeout(() => {
+        finish(() => reject(new Error(`codewiki build worker exceeded ${BUILD_TIMEOUT_MS} ms`)));
+      }, BUILD_TIMEOUT_MS);
+      timer.unref();
+      worker.once("message", (message) => {
+        finish(() => {
+          if (message.ok) resolve2(message.result);
+          else {
+            const error = new Error(message.error);
+            if (message.stack) error.stack = message.stack;
+            reject(error);
+          }
+        });
+      });
+      worker.once(
+        "error",
+        (error) => finish(() => {
+          reject(error);
+        })
+      );
+      worker.once("exit", (code) => {
+        if (code !== 0)
+          finish(() => {
+            reject(new Error(`codewiki build worker exited with code ${code}`));
+          });
+      });
+    });
+  } finally {
+    if (timer) clearTimeout(timer);
+    if (!exited) {
+      await Promise.race([
+        exit,
+        new Promise((resolve2) => {
+          const grace = setTimeout(resolve2, 250);
+          grace.unref();
+        })
+      ]);
     }
-    return lines;
-  } catch {
-    return 0;
+    if (!exited) await worker.terminate().catch(() => void 0);
   }
 }
-function locFromCodewiki(codewiki) {
-  if (!codewiki) return null;
-  return codewiki.files.reduce((sum, file) => file.lang === "config" ? sum : sum + file.loc, 0);
-}
-function accumulateFile(cwd, relPath, hash, artifactLoc) {
-  const absPath = join(cwd, relPath);
-  let stat;
-  try {
-    stat = statSync(absPath);
-  } catch {
-    return 0;
-  }
-  hash.update(`${relPath}:${stat.size}:${Math.floor(stat.mtimeMs)}
-`);
-  if (artifactLoc === null && LOC_EXTENSIONS.has(extensionOf(relPath))) return countLines(absPath);
-  return 0;
+function enqueueWorkspace(cwd, task) {
+  const key = codewikiPath(cwd);
+  const previous = workspaceTails.get(key) ?? Promise.resolve();
+  const result = previous.catch(() => void 0).then(task);
+  const tail = result.then(
+    () => void 0,
+    () => void 0
+  );
+  workspaceTails.set(key, tail);
+  void tail.finally(() => {
+    if (workspaceTails.get(key) === tail) workspaceTails.delete(key);
+  });
+  return result;
 }
-function computeFingerprint(cwd, codewiki = readCodewiki(cwd)) {
-  const files = enumerateWorkspaceFiles(cwd, WORKSPACE_EXCLUDED_DIRS).filter(isIndexablePath);
-  const hash = createHash("sha256");
-  const artifactLoc = locFromCodewiki(codewiki);
-  let loc = 0;
-  for (const relPath of files) loc += accumulateFile(cwd, relPath, hash, artifactLoc);
-  return {
-    treeHash: hash.digest("hex"),
-    gitHead: currentGitHead(cwd),
-    loc: artifactLoc ?? loc
-  };
+function coordinateCodewikiWrite(cwd, select, options = {}) {
+  const workspace = resolve(cwd);
+  return enqueueWorkspace(
+    workspace,
+    () => withStateFileLock(codewikiPath(workspace), async () => {
+      if (options.requireExisting && !existsSync(codewikiPath(workspace))) return null;
+      const current = options.readCurrent?.(workspace) ?? readCodewiki(workspace);
+      const request = await select(current, workspace);
+      if (!request) return null;
+      const worker = await executeInWorker({ ...request, cwd: workspace });
+      await options.beforeCommit?.(worker, workspace);
+      const wrote = worker.changed || !existsSync(codewikiPath(workspace));
+      if (wrote) writeCodewiki(workspace, worker.codewiki);
+      await options.afterCommit?.(worker, workspace);
+      return { codewiki: !worker.changed && current ? current : worker.codewiki, worker, wrote };
+    })
+  );
 }
-async function computeFingerprintAsync(cwd, codewiki = void 0, options = {}) {
-  const slicer = options.slicer ?? createSlicer();
-  const artifact = codewiki === void 0 ? await readCodewikiAsync(cwd) : codewiki;
-  await slicer.tick();
-  const files = (await enumerateWorkspaceFilesAsync(cwd, WORKSPACE_EXCLUDED_DIRS, void 0, slicer)).filter(isIndexablePath);
-  const hash = createHash("sha256");
-  const artifactLoc = locFromCodewiki(artifact);
-  let loc = 0;
-  for (const relPath of files) {
-    await slicer.tick();
-    loc += accumulateFile(cwd, relPath, hash, artifactLoc);
-  }
-  return {
-    treeHash: hash.digest("hex"),
-    gitHead: await currentGitHeadAsync(cwd),
-    loc: artifactLoc ?? loc
-  };
+function coordinateCodewikiExclusive(cwd, task) {
+  const workspace = resolve(cwd);
+  return enqueueWorkspace(workspace, () => withStateFileLock(codewikiPath(workspace), () => task(workspace)));
 }
-function computeFingerprintCached(cwd, codewiki = readCodewiki(cwd), options = {}) {
-  const now = Date.now();
-  const cached = cachedFingerprints.get(cwd);
-  if (cached && cached.expiresAtMs > now) return cached.fingerprint;
-  const fingerprint = computeFingerprint(cwd, codewiki);
-  const ttlMs = options.ttlMs ?? DEFAULT_FINGERPRINT_CACHE_TTL_MS;
-  cachedFingerprints.set(cwd, {
-    fingerprint,
-    expiresAtMs: Date.now() + Math.max(0, ttlMs)
-  });
-  return fingerprint;
+function buildCodewikiCandidate(cwd, language) {
+  return executeInWorker({ kind: "build", cwd: resolve(cwd), language });
 }
-function isStale(prev, curr) {
-  return prev.treeHash !== curr.treeHash;
+async function drainCodewikiWrites(cwd) {
+  const workspace = resolve(cwd);
+  for (; ; ) {
+    const tail = workspaceTails.get(codewikiPath(workspace));
+    if (!tail) return;
+    await tail;
+    if (workspaceTails.get(codewikiPath(workspace)) === tail) return;
+  }
 }
 
 // src/domains/context/state.ts
 init_esm_shims();
-import { existsSync, readFileSync as readFileSync2 } from "node:fs";
-import { join as join2 } from "node:path";
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { join } from "node:path";
 var LEGACY_BOOTSTRAP_GENERATION_MODE = "scout";
 var STATE_RELATIVE_PATH = ".clio-coder/state.json";
 var BOOTSTRAP_GENERATION_MODES = /* @__PURE__ */ new Set(["model", "heuristic", "existing"]);
@@ -247,7 +242,7 @@ function isProjectState(value) {
   return true;
 }
 function statePath(cwd) {
-  return join2(cwd, STATE_RELATIVE_PATH);
+  return join(cwd, STATE_RELATIVE_PATH);
 }
 function migrateLegacyGenerationMode(parsed) {
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return;
@@ -258,10 +253,10 @@ function migrateLegacyGenerationMode(parsed) {
 }
 function readClioState(cwd) {
   const filePath = statePath(cwd);
-  if (!existsSync(filePath)) return null;
+  if (!existsSync2(filePath)) return null;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync2(filePath, "utf8"));
+    parsed = JSON.parse(readFileSync(filePath, "utf8"));
   } catch {
     return null;
   }
@@ -274,12 +269,12 @@ function writeClioState(cwd, state) {
 }
 
 export {
-  computeFingerprint,
-  computeFingerprintAsync,
-  computeFingerprintCached,
-  isStale,
+  coordinateCodewikiWrite,
+  coordinateCodewikiExclusive,
+  buildCodewikiCandidate,
+  drainCodewikiWrites,
   statePath,
   readClioState,
   writeClioState
 };
-//# sourceMappingURL=chunk-BSU2YIWB.js.map
+//# sourceMappingURL=chunk-MVVUPGPW.js.map