@nema-project/nema 0.0.0-stage → 0.1.4

package/dist/repos/handlers.d.ts

@@ -0,0 +1,20 @@
+import type { RpcRouter } from "../daemon/rpc.js";
+import { type GithubReader } from "../github/gh.js";
+import { type GraphifyOpts } from "./graphify.js";
+import type { OwnedHelperScope } from "@nema/shared/ownedHelper";
+export declare function snapshotDir(nemaHome: string, workspaceId: string, repoId: string): string;
+/** Removes the snapshot. A symlink is unlinked and its target is left untouched. */
+export declare function removeSnapshot(dir: string): Promise<void>;
+/**
+ * `graphify` is for tests: production passes the packaged binary, not a PATH lookup.
+ * `github` is the daemon's GitHub provider; the authenticated `gh` CLI is the production default.
+ * `prepareRepo` refreshes that repo before a code call. The daemon passes the watcher.
+ */
+export declare function registerRepoHandlers(router: RpcRouter, opts: {
+    nemaHome: string;
+    graphify?: GraphifyOpts;
+    github?: GithubReader;
+    ownedHelpers?: OwnedHelperScope;
+    pickDirectory?: () => Promise<string | null>;
+    prepareRepo?: (repoId: string, taskId?: string) => Promise<void>;
+}): void;

package/dist/repos/handlers.js

@@ -0,0 +1,255 @@
+import {
+  GH_COMMAND_TOOLS
+} from "../chunks/chunk-HEIQINX3.js";
+
+// repos/handlers.js
+import { lstat, rm, unlink } from "node:fs/promises";
+import path from "node:path";
+import { GITHUB_TOOLS } from "../github/client.js";
+import { GithubGh } from "../github/gh.js";
+import { changedFiles, fetchMain, inspectRepo, mainRef, missingAtRef, readFileAtRef, revParse } from "./git.js";
+import { graphifyInstallStatus, queryIndex } from "./graphify.js";
+import { readIndexedSha, syncIndex, withIndexLock } from "./indexState.js";
+import { pickDirectory as openDirectoryDialog } from "./pickDirectory.js";
+import { checkReport, uncoveredCommits } from "./reportCheck.js";
+var WS_RE = /^ws_[A-Za-z0-9_-]{1,32}$/;
+var REPO_RE = /^repo_[A-Za-z0-9_-]{1,32}$/;
+function repoCall(params) {
+  if (!params || typeof params !== "object")
+    throw new Error("invalid repo params");
+  const row = params;
+  const workspaceId = row.workspaceId;
+  const repoId = row.repoId;
+  const repoPath = row.path;
+  const mainBranch = row.mainBranch;
+  if (typeof workspaceId !== "string" || typeof repoId !== "string" || typeof repoPath !== "string" || typeof mainBranch !== "string") {
+    throw new Error("invalid repo params");
+  }
+  if (!workspaceId || !repoId || !repoPath || !mainBranch)
+    throw new Error("invalid repo params");
+  return { workspaceId, repoId, path: repoPath, mainBranch };
+}
+function snapshotDir(nemaHome, workspaceId, repoId) {
+  if (!WS_RE.test(workspaceId))
+    throw new Error("invalid workspace id");
+  if (!REPO_RE.test(repoId))
+    throw new Error("invalid repo id");
+  const root = path.join(nemaHome, "ws");
+  const dir = path.join(root, workspaceId, "graphify", repoId);
+  const rel = path.relative(root, dir);
+  if (rel === "" || rel === ".." || rel.startsWith(`..${path.sep}`) || path.isAbsolute(rel))
+    throw new Error("invalid workspace id");
+  return dir;
+}
+async function removeSnapshot(dir) {
+  let st;
+  try {
+    st = await lstat(dir);
+  } catch {
+    return;
+  }
+  if (st.isSymbolicLink()) {
+    await unlink(dir);
+    return;
+  }
+  await rm(dir, { recursive: true, force: true });
+}
+var CODE_FUNCTIONS = /* @__PURE__ */ new Set(["code__search", "code__explain", "code__path", "code__read", "code__changes"]);
+function invalidArg(name, field) {
+  return new Error(`${name} \u53C2\u6570\u65E0\u6548\uFF1A${field}`);
+}
+function firstField(name) {
+  switch (name) {
+    case "code__search":
+      return "query";
+    case "code__explain":
+      return "symbol";
+    case "code__read":
+      return "path";
+    default:
+      return "from";
+  }
+}
+function argRecord(name, args) {
+  if (!args || typeof args !== "object" || Array.isArray(args))
+    throw invalidArg(name, firstField(name));
+  return args;
+}
+function needString(name, args, field) {
+  const value = args[field];
+  if (typeof value !== "string")
+    throw invalidArg(name, field);
+  return value;
+}
+function optString(name, args, field) {
+  if (args[field] === void 0)
+    return void 0;
+  return needString(name, args, field);
+}
+function optLine(name, args, field) {
+  if (args[field] === void 0)
+    return void 0;
+  const value = args[field];
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 1)
+    throw invalidArg(name, field);
+  return value;
+}
+function pluginParams(params) {
+  if (!params || typeof params !== "object")
+    throw new Error("\u672A\u77E5\u51FD\u6570");
+  const row = params;
+  const name = row.name;
+  if (typeof name !== "string" || name === "")
+    throw new Error("\u672A\u77E5\u51FD\u6570");
+  if (name.startsWith("github__")) {
+    const tool = name.slice("github__".length);
+    if (!GITHUB_TOOLS.includes(tool) && !GH_COMMAND_TOOLS.includes(tool))
+      throw new Error(`\u672A\u77E5\u51FD\u6570 ${name}`);
+    const args2 = row.args;
+    if (!args2 || typeof args2 !== "object" || Array.isArray(args2))
+      throw new Error(`${name} \u53C2\u6570\u65E0\u6548\uFF1Aargs`);
+    return { name, tool, args: args2 };
+  }
+  if (!CODE_FUNCTIONS.has(name))
+    throw new Error(`\u672A\u77E5\u51FD\u6570 ${name}`);
+  const args = argRecord(name, row.args);
+  switch (name) {
+    case "code__search": {
+      const query = needString(name, args, "query");
+      return { name, repo: repoCall(row.repo), query };
+    }
+    case "code__explain": {
+      const symbol = needString(name, args, "symbol");
+      return { name, repo: repoCall(row.repo), symbol };
+    }
+    case "code__path": {
+      const from = needString(name, args, "from");
+      const to = needString(name, args, "to");
+      return { name, repo: repoCall(row.repo), from, to };
+    }
+    case "code__read": {
+      const relPath = needString(name, args, "path");
+      const startLine = optLine(name, args, "startLine");
+      const endLine = optLine(name, args, "endLine");
+      return { name, repo: repoCall(row.repo), path: relPath, startLine, endLine };
+    }
+    case "code__changes": {
+      const from = needString(name, args, "from");
+      const to = optString(name, args, "to");
+      return { name, repo: repoCall(row.repo), from, to };
+    }
+    default:
+      throw new Error(`\u672A\u77E5\u51FD\u6570 ${name}`);
+  }
+}
+function stringList(params, field, max) {
+  const value = params[field];
+  if (!Array.isArray(value) || value.length > max || !value.every((v) => typeof v === "string"))
+    throw new Error("invalid repo params");
+  return value;
+}
+async function indexLocked(root, repo, graphify) {
+  const helpers = graphify?.ownedHelpers;
+  await fetchMain(repo.path, repo.mainBranch, helpers);
+  const sha = await revParse(repo.path, await mainRef(repo.path, repo.mainBranch, helpers), helpers);
+  await syncIndex(root, repo.path, sha, graphify);
+  return { sha };
+}
+function indexRepo(nemaHome, repo, graphify) {
+  const root = snapshotDir(nemaHome, repo.workspaceId, repo.repoId);
+  return withIndexLock(root, () => indexLocked(root, repo, graphify));
+}
+async function ensureIndex(nemaHome, repo, graphify) {
+  const root = snapshotDir(nemaHome, repo.workspaceId, repo.repoId);
+  await withIndexLock(root, async () => {
+    if (await readIndexedSha(root) === null)
+      await indexLocked(root, repo, graphify);
+  });
+  return root;
+}
+async function runPluginCall(nemaHome, call, github, graphify) {
+  const helpers = graphify?.ownedHelpers;
+  if ("tool" in call)
+    return github.call(call.tool, call.args);
+  switch (call.name) {
+    case "code__search":
+      return queryIndex(await ensureIndex(nemaHome, call.repo, graphify), "query", [call.query], graphify);
+    case "code__explain":
+      return queryIndex(await ensureIndex(nemaHome, call.repo, graphify), "explain", [call.symbol], graphify);
+    case "code__path":
+      return queryIndex(await ensureIndex(nemaHome, call.repo, graphify), "path", [call.from, call.to], graphify);
+    case "code__read": {
+      const ref = await mainRef(call.repo.path, call.repo.mainBranch, helpers);
+      const range = call.startLine !== void 0 || call.endLine !== void 0 ? { startLine: call.startLine, endLine: call.endLine } : void 0;
+      return readFileAtRef(call.repo.path, ref, call.path, range, helpers);
+    }
+    case "code__changes": {
+      const to = call.to ?? await mainRef(call.repo.path, call.repo.mainBranch, helpers);
+      return changedFiles(call.repo.path, call.from, to, call.repo.mainBranch, helpers);
+    }
+  }
+}
+function registerRepoHandlers(router, opts) {
+  const github = opts.github ?? new GithubGh({ ownedHelpers: opts.ownedHelpers });
+  router.register("dialog.pickDirectory", async () => ({ path: await (opts.pickDirectory ?? openDirectoryDialog)() }));
+  router.register("repo.inspect", async (params) => {
+    if (!params || typeof params !== "object" || typeof params.path !== "string") {
+      throw new Error("invalid repo params");
+    }
+    const repoPath = params.path;
+    if (!repoPath)
+      throw new Error("invalid repo params");
+    return inspectRepo(repoPath, opts.nemaHome, opts.ownedHelpers);
+  });
+  router.register("repo.index", async (params) => indexRepo(opts.nemaHome, repoCall(params), opts.graphify));
+  router.register("repo.changes", async (params) => {
+    const repo = repoCall(params);
+    const { from, to } = params;
+    if (typeof from !== "string" || typeof to !== "string" || !from || !to)
+      throw new Error("invalid repo params");
+    return changedFiles(repo.path, from, to, repo.mainBranch, opts.ownedHelpers);
+  });
+  router.register("report.check", async (params) => {
+    const repo = repoCall(params);
+    const commits = stringList(params, "commits", 50);
+    const files = stringList(params, "files", 500);
+    await fetchMain(repo.path, repo.mainBranch, opts.ownedHelpers);
+    return checkReport(repo.path, await mainRef(repo.path, repo.mainBranch, opts.ownedHelpers), commits, files, opts.ownedHelpers);
+  });
+  router.register("repo.uncovered", async (params) => {
+    const repo = repoCall(params);
+    const { from, to } = params;
+    if (typeof from !== "string" || typeof to !== "string" || !from || !to)
+      throw new Error("invalid repo params");
+    const covered = stringList(params, "covered", 1e4);
+    return uncoveredCommits(repo.path, await mainRef(repo.path, repo.mainBranch, opts.ownedHelpers), from, to, covered, opts.ownedHelpers);
+  });
+  router.register("repo.exists", async (params) => {
+    const repo = repoCall(params);
+    const paths = stringList(params, "paths", 500);
+    return { missing: await missingAtRef(repo.path, await mainRef(repo.path, repo.mainBranch, opts.ownedHelpers), paths, opts.ownedHelpers) };
+  });
+  router.register("repo.forget", async (params) => {
+    const repo = repoCall(params);
+    const root = snapshotDir(opts.nemaHome, repo.workspaceId, repo.repoId);
+    await withIndexLock(root, () => removeSnapshot(root));
+    return { ok: true };
+  });
+  router.register("plugin.call", async (params) => {
+    const call = pluginParams(params);
+    if (opts.prepareRepo && "repo" in call) {
+      const taskId = params && typeof params === "object" && typeof params.taskId === "string" ? params.taskId : "";
+      await opts.prepareRepo(call.repo.repoId, taskId === "" ? void 0 : taskId);
+    }
+    return runPluginCall(opts.nemaHome, call, github, opts.graphify);
+  });
+  router.register("plugins.status", async () => {
+    const [code, gh] = await Promise.all([graphifyInstallStatus(opts.graphify), github.status()]);
+    return { code, github: { installed: gh.installed, loggedIn: gh.loggedIn, detail: gh.detail } };
+  });
+}
+export {
+  registerRepoHandlers,
+  removeSnapshot,
+  snapshotDir
+};

package/dist/repos/indexState.d.ts

@@ -0,0 +1,10 @@
+import { type GraphifyOpts } from "./graphify.js";
+/** Runs `fn` after every earlier job for the same snapshot root, so builds never overlap. */
+export declare function withIndexLock<T>(root: string, fn: () => Promise<T>): Promise<T>;
+export declare function readIndexedSha(root: string): Promise<string | null>;
+/**
+ * Brings the index to `sha`. Call it inside `withIndexLock`. An index at another sha is updated
+ * incrementally; no index is built in full. The marker is removed first, so any failure leaves the
+ * snapshot marked as not indexed and the next call rebuilds it in full.
+ */
+export declare function syncIndex(root: string, repoPath: string, sha: string, graphify?: GraphifyOpts): Promise<void>;

package/dist/repos/indexState.js

@@ -0,0 +1,45 @@
+// repos/indexState.js
+import { readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { diffNameStatus, exportSnapshot } from "./git.js";
+import { buildIndex, updateIndex } from "./graphify.js";
+var MARKER = "indexed-sha";
+var locks = /* @__PURE__ */ new Map();
+function withIndexLock(root, fn) {
+  const prev = locks.get(root) ?? Promise.resolve();
+  const run = prev.catch(() => {
+  }).then(fn);
+  locks.set(root, run);
+  void run.catch(() => {
+  }).finally(() => {
+    if (locks.get(root) === run)
+      locks.delete(root);
+  });
+  return run;
+}
+async function readIndexedSha(root) {
+  try {
+    const sha = (await readFile(path.join(root, MARKER), "utf8")).trim();
+    return sha === "" ? null : sha;
+  } catch {
+    return null;
+  }
+}
+async function syncIndex(root, repoPath, sha, graphify) {
+  const indexed = await readIndexedSha(root);
+  if (indexed === sha)
+    return;
+  await rm(path.join(root, MARKER), { force: true });
+  if (indexed !== null) {
+    await updateIndex(root, await diffNameStatus(repoPath, indexed, sha, graphify?.ownedHelpers), repoPath, sha, graphify);
+  } else {
+    await exportSnapshot(repoPath, sha, path.join(root, "src"), graphify?.ownedHelpers);
+    await buildIndex(root, graphify);
+  }
+  await writeFile(path.join(root, MARKER), sha);
+}
+export {
+  readIndexedSha,
+  syncIndex,
+  withIndexLock
+};

package/dist/repos/pickDirectory.d.ts

@@ -0,0 +1,11 @@
+export type CommandRunner = (cmd: string, args: string[], timeoutMs: number) => Promise<{
+    stdout: string;
+}>;
+export declare function pickerCommand(platform: NodeJS.Platform): {
+    cmd: string;
+    args: string[];
+};
+/** A cancelled dialog is an empty result. Anything that is not one absolute path is refused. */
+export declare function normalizePickedPath(stdout: string, platform: NodeJS.Platform): string | null;
+/** Opens the OS folder dialog on this machine. A second call shares the dialog already open. */
+export declare function pickDirectory(platform?: NodeJS.Platform, run?: CommandRunner): Promise<string | null>;

package/dist/repos/pickDirectory.js

@@ -0,0 +1,140 @@
+// repos/pickDirectory.js
+import { execFile } from "node:child_process";
+import path from "node:path";
+var PICK_TIMEOUT_MS = 10 * 60 * 1e3;
+var WIN_FOLDER_SCRIPT = `
+$ErrorActionPreference = 'Stop'
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+public class NemaFolderDialog {
+  [ComImport, Guid("DC1C5A9C-E88A-4dde-A5A1-60F82A20AEF7")]
+  class FileOpenDialogRCW {}
+  [ComImport, Guid("d57c7288-d4ad-4768-be02-9d969532d960"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+  interface IFileOpenDialog {
+    [PreserveSig] int Show(IntPtr parent);
+    void SetFileTypes(uint cFileTypes, IntPtr rgFilterSpec);
+    void SetFileTypeIndex(uint iFileType);
+    void GetFileTypeIndex(out uint piFileType);
+    void Advise(IntPtr pfde, out uint pdwCookie);
+    void Unadvise(uint dwCookie);
+    void SetOptions(uint fos);
+    void GetOptions(out uint fos);
+    void SetDefaultFolder(IShellItem psi);
+    void SetFolder(IShellItem psi);
+    void GetFolder(out IShellItem ppsi);
+    void GetCurrentSelection(out IShellItem ppsi);
+    void SetFileName([MarshalAs(UnmanagedType.LPWStr)] string pszName);
+    void GetFileName([MarshalAs(UnmanagedType.LPWStr)] out string pszName);
+    void SetTitle([MarshalAs(UnmanagedType.LPWStr)] string pszTitle);
+    void SetOkButtonLabel([MarshalAs(UnmanagedType.LPWStr)] string pszText);
+    void SetFileNameLabel([MarshalAs(UnmanagedType.LPWStr)] string pszLabel);
+    void GetResult(out IShellItem ppsi);
+    void AddPlace(IShellItem psi, uint fdap);
+    void SetDefaultExtension([MarshalAs(UnmanagedType.LPWStr)] string pszDefaultExtension);
+    void Close(int hr);
+    void SetClientGuid(ref Guid guid);
+    void ClearClientData();
+    void SetFilter(IntPtr pFilter);
+    void GetResults(out IntPtr ppenum);
+    void GetSelectedItems(out IntPtr ppsai);
+  }
+  [ComImport, Guid("43826D1E-E718-42EE-BC55-A1E261C37BFE"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+  interface IShellItem {
+    void BindToHandler(IntPtr pbc, ref Guid bhid, ref Guid riid, out IntPtr ppv);
+    void GetParent(out IShellItem ppsi);
+    void GetDisplayName(uint sigdnName, out IntPtr ppszName);
+    void GetAttributes(uint sfgaoMask, out uint psfgaoAttribs);
+    void Compare(IShellItem psi, uint hint, out int piOrder);
+  }
+  public static string Pick() {
+    var dialog = (IFileOpenDialog)new FileOpenDialogRCW();
+    dialog.SetOptions(0x20 | 0x40 | 0x800 | 0x8);
+    int hr = dialog.Show(IntPtr.Zero);
+    if (hr == unchecked((int)0x800704C7)) return "";
+    if (hr != 0) Marshal.ThrowExceptionForHR(hr);
+    IShellItem item;
+    dialog.GetResult(out item);
+    IntPtr psz;
+    item.GetDisplayName(0x80058000, out psz);
+    string path = Marshal.PtrToStringUni(psz);
+    Marshal.FreeCoTaskMem(psz);
+    return path ?? "";
+  }
+}
+'@
+[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
+[Console]::Out.Write([NemaFolderDialog]::Pick())
+`;
+function pickerCommand(platform) {
+  if (platform === "win32") {
+    const encoded = Buffer.from(WIN_FOLDER_SCRIPT, "utf16le").toString("base64");
+    return { cmd: "powershell.exe", args: ["-NoProfile", "-STA", "-EncodedCommand", encoded] };
+  }
+  if (platform === "darwin")
+    return { cmd: "osascript", args: ["-e", "POSIX path of (choose folder)"] };
+  return { cmd: "zenity", args: ["--file-selection", "--directory"] };
+}
+function pathApi(platform) {
+  return platform === "win32" ? path.win32 : path.posix;
+}
+function normalizePickedPath(stdout, platform) {
+  const picked = stdout.replace(/^\uFEFF/, "").replace(/\r?\n$/, "").trim();
+  if (!picked || picked.includes("\0") || /[\r\n]/.test(picked) || picked.length > 4096)
+    return null;
+  const api = pathApi(platform);
+  if (!api.isAbsolute(picked))
+    return null;
+  const sep = api.sep;
+  if (picked.length > 3 && (picked.endsWith(sep) || platform === "win32" && picked.endsWith("/")))
+    return picked.slice(0, -1);
+  return picked;
+}
+function isCancel(error) {
+  if (!error || typeof error !== "object")
+    return false;
+  const code = error.code;
+  if (code !== 1 && code !== "1")
+    return false;
+  const stderr = String(error.stderr ?? "");
+  return stderr.trim() === "" || /User canceled|-128/.test(stderr);
+}
+function defaultRun(cmd, args, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    execFile(cmd, args, { windowsHide: true, timeout: timeoutMs, maxBuffer: 64 * 1024, encoding: "utf8" }, (error, stdout, stderr) => {
+      if (error) {
+        error.stderr = stderr;
+        reject(error);
+        return;
+      }
+      resolve({ stdout });
+    });
+  });
+}
+var pending = null;
+function pickDirectory(platform = process.platform, run = defaultRun) {
+  if (pending && run === defaultRun)
+    return pending;
+  const work = (async () => {
+    const { cmd, args } = pickerCommand(platform);
+    try {
+      const { stdout } = await run(cmd, args, PICK_TIMEOUT_MS);
+      return normalizePickedPath(stdout, platform);
+    } catch (error) {
+      if (isCancel(error))
+        return null;
+      throw new Error("\u65E0\u6CD5\u6253\u5F00\u6587\u4EF6\u5939\u9009\u62E9\u5668");
+    }
+  })();
+  if (run !== defaultRun)
+    return work;
+  pending = work.finally(() => {
+    pending = null;
+  });
+  return pending;
+}
+export {
+  normalizePickedPath,
+  pickDirectory,
+  pickerCommand
+};

package/dist/repos/reportCheck.d.ts

@@ -0,0 +1,13 @@
+import type { ReportCheck } from "@nema/shared";
+import type { OwnedHelperScope } from "@nema/shared/ownedHelper";
+/**
+ * Checks reported `commits` and claimed `files` against `mainRefName` (`origin/<main>`, or the local main
+ * when there is no origin). The caller fetches first.
+ */
+export declare function checkReport(repoPath: string, mainRefName: string, commits: string[], files: string[], helpers?: OwnedHelperScope): Promise<ReportCheck>;
+/**
+ * Non-merge commits in `from..to` on main that no report covers: neither one of `covered`, nor patch-id-equal
+ * to one of them, nor a squash of a parent-linked run of covered commits that never reached main themselves.
+ * `from` and `to` must each be `mainRefName` or a sha that main contains. Returned oldest first.
+ */
+export declare function uncoveredCommits(repoPath: string, mainRefName: string, from: string, to: string, covered: string[], helpers?: OwnedHelperScope): Promise<string[]>;