@anhlp/alp-runtime 0.0.0-stage → 0.0.1-beta.4

package/dist/worktree-domain.js

@@ -0,0 +1,199 @@
+// packages/runtime/src/worktree-domain.ts
+import { realpathSync } from "node:fs";
+import path from "node:path";
+import { describeVerification, runVerify, verifyConfig } from "@anhlp/alp-core/verify";
+import { recordVerification, loadTasks } from "@anhlp/alp-core/tasks";
+import { checkoutFingerprint, checkoutKey, commitWorktree, linkModules, mergeWorktree, removeWorktree } from "./workspace.js";
+import { writes } from "./catalog.js";
+import { nativeEnvironment } from "./providers.js";
+import { mainOf } from "./tools.js";
+import { errorData, plainObject, toolResult } from "./tool-results.js";
+function createWorktreeDomain({ options, leases, releaseResult, rootOf, lineage, runLog, runHooks, touchTask }) {
+  const merging = /* @__PURE__ */ new Map();
+  async function settleWorktree(parentId, parent, assignment) {
+    const worktree = assignment.worktree;
+    try {
+      const change = await commitWorktree(worktree, `alp: ${assignment.agent} assignment ${assignment.id}`);
+      if (!change.files.length) {
+        await removeWorktree(worktree, { deleteBranch: true });
+        await releaseResult(assignment.id);
+        return { branch: worktree.branch, files: [], note: "No changes; the worktree was removed" };
+      }
+      const described = { branch: worktree.branch, base: worktree.base, commit: change.commit, files: change.files, stat: change.stat };
+      if (parent.closed) {
+        await removeWorktree(worktree);
+        runLog(rootOf(parentId), { event: "worktree.kept", assignmentId: assignment.id, branch: worktree.branch });
+        return { ...described, note: "The requester closed; the change stays on the branch" };
+      }
+      parent.worktrees.set(assignment.id, { agent: assignment.agent, worktree, change, ...assignment.taskId ? { taskId: assignment.taskId } : {} });
+      return { ...described, next: "Apply it with alp_merge, or drop it with alp_discard" };
+    } catch (error) {
+      await removeWorktree(worktree).catch(() => {
+      });
+      return { branch: worktree.branch, error: errorData(error).message };
+    }
+  }
+  async function worktreeTool(sessionId, session, args, action) {
+    if (!plainObject(args, ["assignmentId", "skipVerify"]) || typeof args.assignmentId !== "string" || args.skipVerify !== void 0 && (action !== "merge" || typeof args.skipVerify !== "string" || !args.skipVerify.trim())) {
+      return toolResult(false, { error: action === "merge" ? "assignmentId is required; skipVerify, when given, says why to merge without verification" : "assignmentId is required" });
+    }
+    const pending = session.worktrees.get(args.assignmentId);
+    if (!pending) {
+      return toolResult(false, { error: session.assignments.has(args.assignmentId) ? "The assignment is still running; wait for its result" : "No unmerged worktree change with that assignment id" });
+    }
+    const { worktree, change } = pending;
+    if (action === "discard") {
+      session.worktrees.delete(args.assignmentId);
+      await removeWorktree(worktree, { deleteBranch: true });
+      await releaseResult(args.assignmentId);
+      runLog(rootOf(sessionId), { event: "worktree.discarded", assignmentId: args.assignmentId, branch: worktree.branch });
+      return toolResult(true, { discarded: args.assignmentId, branch: worktree.branch });
+    }
+    if (!writes(session.mapping.mode)) return toolResult(false, { error: "Merging needs workspace-write or full-access" });
+    if ([...session.assignments.values()].some((assignment) => assignment.mode !== "read-only" && assignment.isolation === "shared")) {
+      return toolResult(false, { error: "A writer assignment is working in this checkout; merge after its result" });
+    }
+    session.worktrees.delete(args.assignmentId);
+    const checkout = await checkoutKey(session.mapping.workdir);
+    const holder = leases.get(checkout);
+    if (holder && !lineage(sessionId).includes(holder.assignment)) {
+      session.worktrees.set(args.assignmentId, pending);
+      return toolResult(false, { error: `${holder.agent} in another session is writing this checkout; merge after it finishes` });
+    }
+    const project = session.mapping.agent.projectRoot;
+    const rootId = rootOf(sessionId);
+    let config;
+    try {
+      config = await verifyConfig(project);
+    } catch (error) {
+      session.worktrees.set(args.assignmentId, pending);
+      return toolResult(false, { error: errorData(error).message });
+    }
+    let verified;
+    if (config && args.skipVerify === void 0) {
+      const verification = verified = await verifyIn(project, worktreeDirectory(worktree, project), config);
+      noteVerification(rootId, project, pending.taskId, args.assignmentId, "worktree", verification);
+      if (!verification.passed) {
+        session.worktrees.set(args.assignmentId, { ...pending, verification });
+        return toolResult(false, {
+          assignmentId: args.assignmentId,
+          error: `${describeVerification(verification)} in the assignment's worktree; nothing was applied`,
+          verification: verificationResult(verification),
+          branch: worktree.branch,
+          next: verification.skipped ? "The check could not run, which says nothing about the change; call alp_merge again, or alp_merge it with skipVerify saying why" : `Delegate again with continueFrom "${args.assignmentId}"${pending.taskId ? ` and taskId ${pending.taskId}` : ""} to fix it in a worktree that starts from this change; or alp_discard it; or alp_merge it with skipVerify saying why`
+        });
+      }
+    } else if (config && pending.taskId) {
+      await recordVerification(project, pending.taskId, { passed: false, skipped: args.skipVerify }, session.mapping.agent.name).catch(() => {
+      });
+      runLog(rootId, { event: "verify", assignmentId: args.assignmentId, where: "worktree", skipped: args.skipVerify });
+    }
+    const refused = await runHooks(sessionId, session, "merge", { assignment: args.assignmentId, branch: worktree.branch }, pending.taskId);
+    if (refused) {
+      session.worktrees.set(args.assignmentId, pending);
+      return toolResult(false, { assignmentId: args.assignmentId, error: `A merge hook refused it; nothing was applied:
+${refused}`, branch: worktree.branch, next: `Fix what it reports in a new assignment with continueFrom "${args.assignmentId}", or alp_discard it` });
+    }
+    let merged;
+    let moved = false;
+    try {
+      ({ merged, moved } = await inCheckout(checkout, async () => {
+        const before = await checkoutFingerprint(worktree.checkout).catch(() => void 0);
+        return { merged: await mergeWorktree(worktree, change), moved: !worktree.fingerprint || before !== worktree.fingerprint };
+      }));
+    } catch (error) {
+      session.worktrees.set(args.assignmentId, pending);
+      return toolResult(false, { error: errorData(error).message, branch: worktree.branch, next: "Merge the branch yourself, or alp_discard it" });
+    }
+    await removeWorktree(worktree, { deleteBranch: merged.status !== "conflicts" });
+    if (merged.status !== "conflicts") await releaseResult(args.assignmentId);
+    runLog(rootId, { event: "worktree.merged", assignmentId: args.assignmentId, branch: worktree.branch, ...merged });
+    let checked;
+    if (config && args.skipVerify === void 0 && merged.status === "applied" && moved) {
+      checked = await inCheckout(checkout, () => verifyIn(project, session.mapping.workdir, config));
+      noteVerification(rootId, project, pending.taskId, args.assignmentId, "checkout", checked);
+    }
+    return toolResult(true, {
+      assignmentId: args.assignmentId,
+      ...merged,
+      ...merged.status === "conflicts" ? { branch: worktree.branch } : {},
+      ...verified ? { verification: verificationResult(checked ?? verified), ...checked ? { verifiedIn: "your checkout, which changed since the assignment started" } : {} } : {},
+      ...args.skipVerify !== void 0 && config ? { verification: { skipped: args.skipVerify } } : {},
+      next: merged.status === "conflicts" ? `Resolve the conflict markers in the listed files, then verify${config ? " with alp_verify" : ""}` : checked && !checked.passed ? `The change passed in its worktree but ${describeVerification(checked)} in your checkout, which changed meanwhile; fix it, then run alp_verify` : "Review the applied change; it is not committed"
+    });
+  }
+  function inCheckout(checkout, work) {
+    const previous = merging.get(checkout) ?? Promise.resolve();
+    const attempt = previous.catch(() => {
+    }).then(work);
+    merging.set(checkout, attempt);
+    void attempt.finally(() => {
+      if (merging.get(checkout) === attempt) merging.delete(checkout);
+    }).catch(() => {
+    });
+    return attempt;
+  }
+  function worktreeDirectory(worktree, project) {
+    let real = project;
+    try {
+      real = realpathSync(project);
+    } catch {
+    }
+    return path.join(worktree.path, path.relative(worktree.checkout, real));
+  }
+  async function verifyIn(project, directory, config) {
+    const same = path.resolve(directory) === path.resolve(project);
+    const unlinkModules = same ? async () => {
+    } : await linkModules(project, directory).catch(() => async () => {
+    });
+    try {
+      return await runVerify(directory, config, { env: nativeEnvironment(options) });
+    } finally {
+      await unlinkModules();
+    }
+  }
+  function verificationResult(verification) {
+    const failed = verification.commands.find((command) => command.exitCode !== 0);
+    return {
+      passed: verification.passed,
+      ...verification.skipped ? { skipped: verification.skipped } : {},
+      steps: verification.commands.map(({ step, command, exitCode, ms, timedOut, idle }) => ({ step, command, exitCode, ms, ...timedOut ? { timedOut } : {}, ...idle ? { idle } : {} })),
+      ...failed?.output ? { output: failed.output } : {}
+    };
+  }
+  function noteVerification(rootId, project, taskId, assignmentId, where, verification) {
+    runLog(rootId, { event: "verify", ...assignmentId ? { assignmentId } : {}, ...taskId ? { taskId } : {}, where, passed: verification.passed, detail: describeVerification(verification) });
+    if (taskId) void recordVerification(project, taskId, { ...verification, where }, "alpd").then(() => touchTask(rootId, taskId), () => {
+    });
+  }
+  function continuedBrief(from, continued) {
+    const failed = continued.verification?.commands.find((command) => command.exitCode !== 0);
+    return `Your worktree starts from the change of ${continued.agent}'s assignment ${from}, committed on your branch (${continued.change.files.length} files: ${continued.change.files.slice(0, 20).join(", ")}). Build on it rather than starting over.` + (continued.verification && !continued.verification.passed ? ` The project's checks failed on it: ${describeVerification(continued.verification)}, running \`${failed?.command}\`. The end of its output:
+${failed?.output.slice(-1500) ?? ""}` : "");
+  }
+  async function verifyTool(sessionId, session, args) {
+    if (!plainObject(args, ["taskId"]) || args.taskId !== void 0 && typeof args.taskId !== "string") return toolResult(false, { error: "alp_verify takes only taskId" });
+    if (args.taskId !== void 0 && (session.parent || session.mapping.agent.name !== mainOf(session.mapping))) return toolResult(false, { error: "Only main records a verification on a task; call alp_verify without taskId" });
+    const project = session.mapping.agent.projectRoot;
+    let config;
+    try {
+      config = await verifyConfig(project);
+    } catch (error) {
+      return toolResult(false, { error: errorData(error).message });
+    }
+    if (!config) return toolResult(false, { error: "This project has no verify commands (verify in .alp/settings.json); run its checks yourself" });
+    if (args.taskId !== void 0) {
+      const task = (await loadTasks(project)).tasks.find((entry) => entry.id === args.taskId);
+      if (!task) return toolResult(false, { error: `No task ${args.taskId}` });
+      if (task.status === "closed") return toolResult(false, { error: `${args.taskId} is closed` });
+    }
+    const checkout = await checkoutKey(session.mapping.workdir);
+    const verification = await inCheckout(checkout, () => verifyIn(project, session.mapping.workdir, config));
+    noteVerification(rootOf(sessionId), project, args.taskId, void 0, "checkout", verification);
+    return toolResult(true, { ...verificationResult(verification), summary: describeVerification(verification), ...args.taskId ? { recordedOn: args.taskId } : {} });
+  }
+  return { settleWorktree, worktreeTool, inCheckout, verifyIn, verificationResult, noteVerification, continuedBrief, verifyTool };
+}
+export {
+  createWorktreeDomain
+};

package/package.json

@@ -1,6 +1,264 @@
 {
   "name": "@anhlp/alp-runtime",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.1-beta.4",
+  "type": "module",
+  "description": "ALP runtime module",
+  "files": [
+    "src",
+    "dist",
+    "NOTICE"
+  ],
+  "exports": {
+    "./acp-transport": {
+      "alp-source": {
+        "types": "./src/acp-transport.ts",
+        "default": "./src/acp-transport.ts"
+      },
+      "types": "./dist/acp-transport.d.ts",
+      "default": "./dist/acp-transport.js"
+    },
+    "./antigravity-transport": {
+      "alp-source": {
+        "types": "./src/antigravity-transport.ts",
+        "default": "./src/antigravity-transport.ts"
+      },
+      "types": "./dist/antigravity-transport.d.ts",
+      "default": "./dist/antigravity-transport.js"
+    },
+    "./attachments": {
+      "alp-source": {
+        "types": "./src/attachments.ts",
+        "default": "./src/attachments.ts"
+      },
+      "types": "./dist/attachments.d.ts",
+      "default": "./dist/attachments.js"
+    },
+    "./board": {
+      "alp-source": {
+        "types": "./src/board.ts",
+        "default": "./src/board.ts"
+      },
+      "types": "./dist/board.d.ts",
+      "default": "./dist/board.js"
+    },
+    "./catalog": {
+      "alp-source": {
+        "types": "./src/catalog.ts",
+        "default": "./src/catalog.ts"
+      },
+      "types": "./dist/catalog.d.ts",
+      "default": "./dist/catalog.js"
+    },
+    "./claude-transport": {
+      "alp-source": {
+        "types": "./src/claude-transport.ts",
+        "default": "./src/claude-transport.ts"
+      },
+      "types": "./dist/claude-transport.d.ts",
+      "default": "./dist/claude-transport.js"
+    },
+    "./contracts": {
+      "alp-source": {
+        "types": "./src/contracts.ts",
+        "default": "./src/contracts.ts"
+      },
+      "types": "./dist/contracts.d.ts",
+      "default": "./dist/contracts.js"
+    },
+    "./events": {
+      "alp-source": {
+        "types": "./src/events.ts",
+        "default": "./src/events.ts"
+      },
+      "types": "./dist/events.d.ts",
+      "default": "./dist/events.js"
+    },
+    "./github": {
+      "alp-source": {
+        "types": "./src/github.ts",
+        "default": "./src/github.ts"
+      },
+      "types": "./dist/github.d.ts",
+      "default": "./dist/github.js"
+    },
+    "./handoff": {
+      "alp-source": {
+        "types": "./src/handoff.ts",
+        "default": "./src/handoff.ts"
+      },
+      "types": "./dist/handoff.d.ts",
+      "default": "./dist/handoff.js"
+    },
+    "./index": {
+      "alp-source": {
+        "types": "./src/index.ts",
+        "default": "./src/index.ts"
+      },
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    ".": {
+      "alp-source": {
+        "types": "./src/index.ts",
+        "default": "./src/index.ts"
+      },
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./language": {
+      "alp-source": {
+        "types": "./src/language.ts",
+        "default": "./src/language.ts"
+      },
+      "types": "./dist/language.d.ts",
+      "default": "./dist/language.js"
+    },
+    "./live": {
+      "alp-source": {
+        "types": "./src/live.ts",
+        "default": "./src/live.ts"
+      },
+      "types": "./dist/live.d.ts",
+      "default": "./dist/live.js"
+    },
+    "./mailbox": {
+      "alp-source": {
+        "types": "./src/mailbox.ts",
+        "default": "./src/mailbox.ts"
+      },
+      "types": "./dist/mailbox.d.ts",
+      "default": "./dist/mailbox.js"
+    },
+    "./mcp-tools": {
+      "alp-source": {
+        "types": "./src/mcp-tools.ts",
+        "default": "./src/mcp-tools.ts"
+      },
+      "types": "./dist/mcp-tools.d.ts",
+      "default": "./dist/mcp-tools.js"
+    },
+    "./process-info": {
+      "alp-source": {
+        "types": "./src/process-info.ts",
+        "default": "./src/process-info.ts"
+      },
+      "types": "./dist/process-info.d.ts",
+      "default": "./dist/process-info.js"
+    },
+    "./providers": {
+      "alp-source": {
+        "types": "./src/providers.ts",
+        "default": "./src/providers.ts"
+      },
+      "types": "./dist/providers.d.ts",
+      "default": "./dist/providers.js"
+    },
+    "./recall": {
+      "alp-source": {
+        "types": "./src/recall.ts",
+        "default": "./src/recall.ts"
+      },
+      "types": "./dist/recall.d.ts",
+      "default": "./dist/recall.js"
+    },
+    "./resolve": {
+      "alp-source": {
+        "types": "./src/resolve.ts",
+        "default": "./src/resolve.ts"
+      },
+      "types": "./dist/resolve.d.ts",
+      "default": "./dist/resolve.js"
+    },
+    "./runtime-context": {
+      "alp-source": {
+        "types": "./src/runtime-context.ts",
+        "default": "./src/runtime-context.ts"
+      },
+      "types": "./dist/runtime-context.d.ts",
+      "default": "./dist/runtime-context.js"
+    },
+    "./runtime": {
+      "alp-source": {
+        "types": "./src/runtime.ts",
+        "default": "./src/runtime.ts"
+      },
+      "types": "./dist/runtime.d.ts",
+      "default": "./dist/runtime.js"
+    },
+    "./session-config": {
+      "alp-source": {
+        "types": "./src/session-config.ts",
+        "default": "./src/session-config.ts"
+      },
+      "types": "./dist/session-config.d.ts",
+      "default": "./dist/session-config.js"
+    },
+    "./tools": {
+      "alp-source": {
+        "types": "./src/tools.ts",
+        "default": "./src/tools.ts"
+      },
+      "types": "./dist/tools.d.ts",
+      "default": "./dist/tools.js"
+    },
+    "./transport": {
+      "alp-source": {
+        "types": "./src/transport.ts",
+        "default": "./src/transport.ts"
+      },
+      "types": "./dist/transport.d.ts",
+      "default": "./dist/transport.js"
+    },
+    "./usage": {
+      "alp-source": {
+        "types": "./src/usage.ts",
+        "default": "./src/usage.ts"
+      },
+      "types": "./dist/usage.d.ts",
+      "default": "./dist/usage.js"
+    },
+    "./workspace": {
+      "alp-source": {
+        "types": "./src/workspace.ts",
+        "default": "./src/workspace.ts"
+      },
+      "types": "./dist/workspace.d.ts",
+      "default": "./dist/workspace.js"
+    }
+  },
+  "engines": {
+    "node": ">=22.12"
+  },
+  "dependencies": {
+    "@anhlp/alp-core": "0.0.1-beta.4",
+    "@anhlp/alp-protocol": "0.0.1-beta.4",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.292",
+    "@modelcontextprotocol/sdk": "^1.32.1",
+    "@agentclientprotocol/sdk": "1.7.0",
+    "smol-toml": "1.9.0",
+    "zod": "4.4.3"
+  },
+  "scripts": {
+    "build": "node ../../scripts/build-workspace.mjs runtime",
+    "test": "node ../../scripts/test-package.mjs runtime",
+    "prepack": "npm run build"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/",
+    "tag": "beta"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/phucanh08/alp.git",
+    "directory": "packages/runtime"
+  },
+  "homepage": "https://github.com/phucanh08/alp/tree/main/packages/runtime#readme",
+  "bugs": {
+    "url": "https://github.com/phucanh08/alp/issues"
+  },
+  "devDependencies": {
+    "ajv": "8.20.0"
+  }
+}