alp-code 0.9.0

package/dist/src/agents/titling.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.titlingAgent = void 0;
+const agent_definition_1 = require("./agent-definition");
+const voice_1 = require("./shared/voice");
+const types_1 = require("../workflow/types");
+exports.titlingAgent = (0, agent_definition_1.defineAgent)({
+    id: "titling",
+    displayName: "Titling 🏷️",
+    model: { claude: "claude-haiku-4-5", codex: "gpt-5.6-luna" },
+    reasoningEffort: { claude: "low", codex: "low" },
+    reportsTo: "main",
+    delegatesTo: [],
+    // Một cái tiêu đề gần như không cần gì; sàn là có chủ ý.
+    autoCompactTokens: { claude: 100_000, codex: 100_000 },
+    capabilities: {
+        tools: [],
+        skills: [],
+        subagents: [],
+        mcpServers: [],
+        memory: { read: ["private:titling"], write: ["private:titling"] },
+        workspace: { readRoots: [], writeRoots: [] },
+    },
+    instructions: () => (0, voice_1.renderInstructions)("Titling, the thread-title specialist", "Infer the primary intent and return exactly one short title in the thread's main language.", 
+    // No house rules: titling holds no tools and no memory but its own, so every one of them
+    // governs something it cannot reach. Its whole contract is the one line below.
+    ["No quotes, label, explanation, alternatives, trailing punctuation, task execution, or principal communication."], { audience: "machine" }),
+    workflow: (0, types_1.defineLinearWorkflow)("title-thread", [
+        { id: "TITLE", allowedTools: [] },
+    ]),
+    output: (0, voice_1.textOutput)("thread-title"),
+});

package/dist/src/agents/types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUNTIME_IDS = exports.TOOL_CATALOG = void 0;
+exports.TOOL_CATALOG = [
+    "Read",
+    "Write",
+    "Edit",
+    "Glob",
+    "Grep",
+    "Bash",
+    "WebSearch",
+    "WebFetch",
+    "Skill",
+];
+exports.RUNTIME_IDS = ["claude", "codex"];

package/dist/src/backend/execution-backend.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/backend/local-execution-store.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileLocalExecutionStore = exports.InMemoryLocalExecutionStore = void 0;
+exports.localStateFile = localStateFile;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+/** Default store for a backend constructed without a state directory, and for tests. */
+class InMemoryLocalExecutionStore {
+    records = new Map();
+    get(executionId) {
+        return this.records.get(executionId) ?? null;
+    }
+    put(record) {
+        this.records.set(record.executionId, Object.freeze({ ...record }));
+    }
+    update(executionId, patch) {
+        const current = this.records.get(executionId);
+        if (!current)
+            return null;
+        const next = Object.freeze({ ...current, ...patch, updatedAt: new Date().toISOString() });
+        this.records.set(executionId, next);
+        return next;
+    }
+    remove(executionId) {
+        this.records.delete(executionId);
+    }
+    list() {
+        return Object.freeze([...this.records.values()]);
+    }
+}
+exports.InMemoryLocalExecutionStore = InMemoryLocalExecutionStore;
+/**
+ * Durable record of every execution this backend started, written to `<stateDir>/local.json`.
+ *
+ * Locking is not optional here, unlike in `FileDelegationExecutionStore`: `status()`
+ * reconciles a dead pid into a terminal record, so two concurrent `alp` processes polling
+ * the same execution both read-modify-write, and the loser's update would vanish. The lock
+ * is a directory because `mkdir` is atomic on every filesystem this runs on; a lock older
+ * than `STALE_LOCK_MS` is assumed to belong to a process that died holding it.
+ */
+class FileLocalExecutionStore {
+    static STALE_LOCK_MS = 30_000;
+    static LOCK_TIMEOUT_MS = 5_000;
+    file;
+    constructor(options) {
+        this.file = (0, node_path_1.resolve)(options.file);
+    }
+    get(executionId) {
+        return this.read().executions[executionId] ?? null;
+    }
+    put(record) {
+        this.mutate((state) => {
+            state.executions[record.executionId] = { ...record };
+            return undefined;
+        });
+    }
+    update(executionId, patch) {
+        return this.mutate((state) => {
+            const current = state.executions[executionId];
+            if (!current)
+                return null;
+            const next = { ...current, ...patch, updatedAt: new Date().toISOString() };
+            state.executions[executionId] = next;
+            return next;
+        });
+    }
+    remove(executionId) {
+        this.mutate((state) => {
+            delete state.executions[executionId];
+            return undefined;
+        });
+    }
+    list() {
+        return Object.freeze(Object.values(this.read().executions));
+    }
+    read() {
+        try {
+            const parsed = JSON.parse((0, node_fs_1.readFileSync)(this.file, "utf8"));
+            return { version: 1, executions: { ...(parsed.executions ?? {}) } };
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return { version: 1, executions: {} };
+            throw new Error(`local delegation state is unreadable at ${this.file}: ${error.message}`, { cause: error });
+        }
+    }
+    write(state) {
+        const directory = (0, node_path_1.dirname)(this.file);
+        (0, node_fs_1.mkdirSync)(directory, { recursive: true, mode: 0o700 });
+        const temporary = `${this.file}.${process.pid}.tmp`;
+        try {
+            (0, node_fs_1.writeFileSync)(temporary, `${JSON.stringify(state, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+            (0, node_fs_1.renameSync)(temporary, this.file);
+        }
+        finally {
+            (0, node_fs_1.rmSync)(temporary, { force: true });
+        }
+    }
+    mutate(change) {
+        const unlock = this.lock();
+        try {
+            const state = this.read();
+            const value = change(state);
+            this.write(state);
+            return value;
+        }
+        finally {
+            unlock();
+        }
+    }
+    lock() {
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(this.file), { recursive: true, mode: 0o700 });
+        const lockDirectory = `${this.file}.lock`;
+        const deadline = Date.now() + FileLocalExecutionStore.LOCK_TIMEOUT_MS;
+        for (;;) {
+            try {
+                (0, node_fs_1.mkdirSync)(lockDirectory);
+                return () => (0, node_fs_1.rmSync)(lockDirectory, { recursive: true, force: true });
+            }
+            catch (error) {
+                if (error.code !== "EEXIST")
+                    throw error;
+                try {
+                    if (Date.now() - (0, node_fs_1.statSync)(lockDirectory).mtimeMs > FileLocalExecutionStore.STALE_LOCK_MS) {
+                        (0, node_fs_1.rmSync)(lockDirectory, { recursive: true, force: true });
+                        continue;
+                    }
+                }
+                catch { /* the holder released it between our failed mkdir and this stat */ }
+                if (Date.now() >= deadline)
+                    throw new Error(`timed out locking local delegation state ${this.file}`);
+                sleepSync(20);
+            }
+        }
+    }
+}
+exports.FileLocalExecutionStore = FileLocalExecutionStore;
+/** Blocks the thread without a busy loop; the lock is held for microseconds at a time. */
+function sleepSync(milliseconds) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
+}
+function localStateFile(stateDir) {
+    return (0, node_path_1.join)((0, node_path_1.resolve)(stateDir), "local.json");
+}