s-app-scoder-agent 0.5.0 → 0.7.0

package/dist/session.js

@@ -1,8 +1,17 @@
 /**
- * Session persistence: save agent state (messages, steps, build) to
- * <workdir>/.scoder/sessions/<id>.json after every step so runs can be resumed.
+ * Session persistence v2: durable event log + projections.
+ *
+ * Source: anomalyco/opencode (packages/core/src/session/stored.ts, run-coordinator.ts;
+ * specs/v2/session.md) — pattern adapted: event-sourced JSONL log as the durable
+ * source, in-memory projection for messages, write-ahead execution claim for
+ * crash recovery. Falls back to reading v1 JSON snapshots transparently.
+ *
+ * Layout:
+ *   <workdir>/.scoder/sessions/<id>.json       — v1 snapshot (legacy, read-only)
+ *   <workdir>/.scoder/sessions/<id>/events.jsonl — v2 durable event log
+ *   <workdir>/.scoder/sessions/<id>/manifest.json — projection summary
  */
-import { mkdirSync, writeFileSync, renameSync, readFileSync, readdirSync, existsSync, rmSync, statSync } from "node:fs";
+import { mkdirSync, writeFileSync, appendFileSync, renameSync, readFileSync, readdirSync, existsSync, rmSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
 const SESSIONS_DIR = ".scoder/sessions";
 export function newSessionId(now = new Date()) {
@@ -19,12 +28,192 @@ export function newSessionId(now = new Date()) {
 function sessionsDir(workdir) {
     return resolve(workdir, SESSIONS_DIR);
 }
+function eventLogPath(workdir, id) {
+    return join(sessionsDir(workdir), id, "events.jsonl");
+}
+function manifestPath(workdir, id) {
+    return join(sessionsDir(workdir), id, "manifest.json");
+}
 /** Atomic write: write to .tmp then rename. */
 function atomicWrite(path, content) {
+    mkdirSync(resolve(path, ".."), { recursive: true });
     const tmp = `${path}.tmp`;
     writeFileSync(tmp, content, "utf8");
     renameSync(tmp, path);
 }
+/** ---------------------------------------------------------------------
+ * Event-sourced store (v2)
+ * ------------------------------------------------------------------- */
+export class EventSessionStore {
+    id;
+    enabled;
+    _workdir;
+    seq = 0;
+    createdAt;
+    logPath;
+    /** In-memory projection: message history (append-only). */
+    _messages = [];
+    _task = "";
+    _steps = 0;
+    _lastBuild = null;
+    _usage = undefined;
+    _finished = null;
+    constructor(workdir, enabled, id = newSessionId()) {
+        this.id = id;
+        this._workdir = workdir;
+        this.enabled = enabled;
+        this.createdAt = new Date().toISOString();
+        this.logPath = eventLogPath(workdir, id);
+        if (enabled) {
+            try {
+                mkdirSync(resolve(this.logPath, ".."), { recursive: true });
+            }
+            catch (err) {
+                // Never crash the agent because of a persistence failure
+                console.error(`⚠  session store init failed: ${err.message}`);
+                this.enabled = false;
+            }
+        }
+    }
+    get workdir() {
+        return this._workdir;
+    }
+    /** Append one durable event (fsync-free appendFileSync is atomic enough per line on POSIX). */
+    append(event) {
+        if (!this.enabled)
+            return;
+        try {
+            const full = {
+                ts: event.ts ?? new Date().toISOString(),
+                v: 1,
+                seq: ++this.seq,
+                ...event,
+            };
+            appendFileSync(this.logPath, JSON.stringify(full) + "\n", "utf8");
+            this.project(full);
+        }
+        catch (err) {
+            console.error(`⚠  event append failed: ${err.message}`);
+        }
+    }
+    /** Update the in-memory projection from an event. */
+    project(ev) {
+        switch (ev.type) {
+            case "run.started":
+                this._task = String(ev.task ?? "");
+                break;
+            case "message.added":
+                this._messages.push(ev.message);
+                break;
+            case "build.checked":
+                this._lastBuild = {
+                    success: Boolean(ev.success),
+                    command: String(ev.command ?? ""),
+                    output: String(ev.output ?? "").slice(0, 10_000),
+                };
+                break;
+            case "finish":
+                this._finished = { success: Boolean(ev.success), summary: String(ev.summary ?? "") };
+                break;
+            default:
+                break; // tool/guardrail/etc. events are queryable from the raw log
+        }
+    }
+    /** Materialized message history (projection). */
+    get messages() {
+        return this._messages;
+    }
+    /** Write-ahead execution claim — stamped when a step begins executing. */
+    claimExecution(attempt) {
+        this.append({
+            type: "execution.claimed",
+            attempt,
+            pid: process.pid,
+            host: process.env.HOSTNAME ?? "localhost",
+        });
+    }
+    releaseExecution(attempt) {
+        this.append({ type: "execution.released", attempt });
+    }
+    /** Crash recovery: sessions with a stale claim (no matching release). */
+    static hasStaleClaim(workdir, id) {
+        const events = readEventLog(workdir, id);
+        let claimed = 0;
+        let released = 0;
+        for (const ev of events) {
+            if (ev.type === "execution.claimed")
+                claimed++;
+            if (ev.type === "execution.released")
+                released++;
+        }
+        return claimed > released;
+    }
+    /** Full projection → the v1 SessionFile shape (resume/read compatibility). */
+    toSessionFile() {
+        return {
+            id: this.id,
+            createdAt: this.createdAt,
+            updatedAt: new Date().toISOString(),
+            task: this._task,
+            model: "",
+            provider: "",
+            buildCmd: null,
+            steps: this._steps,
+            maxSteps: 0,
+            messages: this._messages,
+            lastBuild: this._lastBuild,
+            usage: this._usage,
+        };
+    }
+    get finished() {
+        return this._finished;
+    }
+    /** Persist a manifest (cheap summary for /sessions listing). */
+    writeManifest(meta) {
+        if (!this.enabled)
+            return;
+        try {
+            atomicWrite(manifestPath(this._workdir, this.id), JSON.stringify({
+                id: this.id,
+                createdAt: this.createdAt,
+                updatedAt: new Date().toISOString(),
+                lastBuild: this._lastBuild,
+                finished: this._finished,
+                eventCount: this.seq,
+                ...meta,
+            }, null, 2));
+            this._steps = meta.steps;
+            this._usage = meta.usage;
+        }
+        catch (err) {
+            console.error(`⚠  manifest write failed: ${err.message}`);
+        }
+    }
+}
+/** Read the raw event log of a session (empty array when missing/malformed lines). */
+export function readEventLog(workdir, id) {
+    const p = eventLogPath(workdir, id);
+    if (!existsSync(p))
+        return [];
+    const out = [];
+    try {
+        const text = readFileSync(p, "utf8");
+        for (const line of text.split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                out.push(JSON.parse(line));
+            }
+            catch {
+                // skip malformed line (torn write on crash) — remaining lines stay valid
+            }
+        }
+    }
+    catch {
+        return [];
+    }
+    return out;
+}
 export class SessionStore {
     id;
     filePath;
@@ -60,6 +249,11 @@ export class SessionStore {
 // Load / list / prune
 // ---------------------------------------------------------------------------
 export function loadSession(workdir, id) {
+    // v2 event-sourced session directory first
+    const v2Dir = join(sessionsDir(workdir), id);
+    if (existsSync(v2Dir) && statSync(v2Dir).isDirectory()) {
+        return sessionFromEventLog(workdir, id);
+    }
     const path = join(sessionsDir(workdir), `${id}.json`);
     if (!existsSync(path))
         return null;
@@ -70,11 +264,69 @@ export function loadSession(workdir, id) {
         return null;
     }
 }
+/** Rebuild a SessionFile projection from a v2 event log (null when no log). */
+export function sessionFromEventLog(workdir, id) {
+    const events = readEventLog(workdir, id);
+    if (events.length === 0)
+        return null;
+    const messages = [];
+    let task = "";
+    let lastBuild = null;
+    let createdAt = "";
+    let updatedAt = "";
+    for (const ev of events) {
+        createdAt = createdAt || ev.ts;
+        updatedAt = ev.ts;
+        if (ev.type === "run.started")
+            task = String(ev.task ?? "");
+        else if (ev.type === "message.added")
+            messages.push(ev.message);
+        else if (ev.type === "build.checked") {
+            lastBuild = { success: Boolean(ev.success), command: String(ev.command ?? ""), output: String(ev.output ?? "") };
+        }
+    }
+    const manifest = existsSync(manifestPath(workdir, id))
+        ? JSON.parse(readFileSync(manifestPath(workdir, id), "utf8"))
+        : {};
+    return {
+        id,
+        createdAt,
+        updatedAt,
+        task,
+        model: manifest.model ?? "",
+        provider: manifest.provider ?? "",
+        buildCmd: manifest.buildCmd ?? null,
+        steps: manifest.steps ?? 0,
+        maxSteps: manifest.maxSteps ?? 0,
+        messages,
+        lastBuild,
+        usage: manifest.usage,
+    };
+}
 export function listSessions(workdir) {
     const dir = sessionsDir(workdir);
     if (!existsSync(dir))
         return [];
     const out = [];
+    // v2 event-sourced sessions (directories with manifest.json), newest first
+    const v2 = [];
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+        if (!e.isDirectory())
+            continue;
+        const mf = join(dir, e.name, "manifest.json");
+        if (!existsSync(mf))
+            continue;
+        try {
+            const m = JSON.parse(readFileSync(mf, "utf8"));
+            v2.push({ id: m.id, task: (m.task ?? "").slice(0, 60), steps: m.steps ?? 0, updatedAt: m.updatedAt ?? "" });
+        }
+        catch {
+            // skip malformed
+        }
+    }
+    v2.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt) || b.id.localeCompare(a.id));
+    out.push(...v2);
+    // v1 JSON snapshots (legacy, read-only)
     for (const f of readdirSync(dir).sort().reverse()) {
         if (!f.endsWith(".json"))
             continue;
@@ -95,9 +347,10 @@ export function listSessions(workdir) {
 }
 /**
  * Delete session files older than `days` (default 7).
- * Completed sessions (lastBuild.success === true) are removed; sessions that
- * did NOT finish successfully are kept longer — they may still be worth
- * resuming. Returns count removed.
+ * v2: removes the session DIRECTORY (events+manifest). v1: removes the .json.
+ * Completed sessions (finished.success) are removed; sessions that did NOT
+ * finish successfully are kept longer — they may still be worth resuming.
+ * Returns count removed.
  */
 export function pruneSessions(workdir, days = 7) {
     const dir = sessionsDir(workdir);
@@ -105,14 +358,32 @@ export function pruneSessions(workdir, days = 7) {
         return 0;
     const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
     let removed = 0;
-    for (const f of readdirSync(dir)) {
-        if (!f.endsWith(".json"))
-            continue;
-        const full = join(dir, f);
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+        const full = join(dir, e.name);
         try {
             const st = statSync(full);
             if (st.mtimeMs >= cutoff)
                 continue;
+            if (e.isDirectory()) {
+                // v2 session dir — check manifest for finished status
+                const mf = join(full, "manifest.json");
+                let completed = false;
+                if (existsSync(mf)) {
+                    try {
+                        completed = JSON.parse(readFileSync(mf, "utf8")).finished?.success === true;
+                    }
+                    catch {
+                        completed = false;
+                    }
+                }
+                if (completed) {
+                    rmSync(full, { recursive: true, force: true });
+                    removed++;
+                }
+                continue;
+            }
+            if (!e.name.endsWith(".json"))
+                continue;
             const s = JSON.parse(readFileSync(full, "utf8"));
             const completed = s.lastBuild?.success === true;
             if (completed) {
@@ -123,7 +394,7 @@ export function pruneSessions(workdir, days = 7) {
         catch {
             // malformed JSON — prune it (unreadable session is worthless)
             try {
-                rmSync(full);
+                rmSync(full, { recursive: true, force: true });
                 removed++;
             }
             catch { /* ignore */ }

package/dist/shell-scanner.js

@@ -0,0 +1,112 @@
+/**
+ * Shell scanner — AST-aware permission analysis using tree-sitter-bash.
+ *
+ * Source: anomalyco/opencode (shell permission scanner, /v2/docs/permissions) —
+ * concept adapted to tree-sitter-bash on Node. Behavior contract:
+ *  - A syntactically INVALID command (or dynamic evaluation the scanner
+ *    cannot resolve) returns { ok: false, error } — the caller must treat it
+ *    as "ask" (never execute unverified).
+ *  - Compound commands produce one resource per subcommand; redirect targets
+ *    are reported so callers can gate external writes.
+ *  - `cd <dir>` targets are extracted for external_directory gating.
+ */
+import Parser from "tree-sitter";
+import Bash from "tree-sitter-bash";
+let parser = null;
+function getParser() {
+    if (!parser) {
+        parser = new Parser();
+        parser.setLanguage(Bash);
+    }
+    return parser;
+}
+function collect(root) {
+    const commandNames = [];
+    const commandLines = [];
+    const redirectTargets = [];
+    const cdTargets = [];
+    let hasCommandSubstitution = false;
+    let hasDynamicEval = false;
+    let hasError = root.hasError;
+    const walk = (n) => {
+        if (n.type === "ERROR")
+            hasError = true;
+        if (n.type === "command_substitution" || n.type === "process_substitution") {
+            hasCommandSubstitution = true;
+        }
+        if (n.type === "command") {
+            const nameNode = n.child(0);
+            const name = nameNode?.type === "command_name" ? nameNode.text : "";
+            if (name) {
+                commandNames.push(name);
+                commandLines.push(n.text);
+                if (name === "cd") {
+                    const firstArg = n.child(1);
+                    if (firstArg && firstArg.type !== "command_name")
+                        cdTargets.push(firstArg.text);
+                }
+                if (name === "eval" || name === "source" || name === ".")
+                    hasDynamicEval = true;
+            }
+        }
+        if (n.type === "file_redirect") {
+            // child(0) = operator (>, >>), child(1) = destination word
+            const dest = n.child(1)?.text ?? "";
+            if (dest)
+                redirectTargets.push(dest);
+        }
+        if (n.type === "heredoc_redirect") {
+            // heredoc body is safe to ignore, but the target word matters
+            const dest = n.child(0)?.text ?? "";
+            if (dest)
+                redirectTargets.push(dest);
+        }
+        for (let i = 0; i < n.childCount; i++) {
+            const c = n.child(i);
+            if (c)
+                walk(c);
+        }
+    };
+    walk(root);
+    return { commandNames, commandLines, redirectTargets, cdTargets, hasCommandSubstitution, hasDynamicEval, hasError };
+}
+/** Scan one shell command line (exactly what run_command would execute). */
+export function scanCommand(command) {
+    const empty = {
+        ok: false,
+        error: "empty command",
+        commands: [],
+        commandLines: [],
+        redirectTargets: [],
+        cdTargets: [],
+        hasCommandSubstitution: false,
+        hasDynamicEval: false,
+    };
+    if (!command || !command.trim())
+        return empty;
+    let tree;
+    try {
+        tree = getParser().parse(command);
+    }
+    catch (err) {
+        return { ...empty, error: `scanner parse failure: ${err.message}` };
+    }
+    const r = collect(tree.rootNode);
+    if (r.hasError) {
+        return {
+            ...empty,
+            error: "command has invalid syntax or unresolvable constructs — approval required",
+            hasCommandSubstitution: r.hasCommandSubstitution,
+            hasDynamicEval: r.hasDynamicEval,
+        };
+    }
+    return {
+        ok: true,
+        commands: r.commandNames,
+        commandLines: r.commandLines,
+        redirectTargets: r.redirectTargets,
+        cdTargets: r.cdTargets,
+        hasCommandSubstitution: r.hasCommandSubstitution,
+        hasDynamicEval: r.hasDynamicEval,
+    };
+}

package/dist/skills.js

@@ -0,0 +1,122 @@
+/**
+ * Skill discovery & loading for scoder.
+ *
+ * A skill is a directory containing a SKILL.md file with YAML-lite frontmatter:
+ *
+ *   ---
+ *   name: code-review
+ *   description: Review code for bugs, security issues, and style
+ *   ---
+ *   (markdown instructions the agent follows)
+ *
+ * Discovery order (later wins on name conflict):
+ *   1. ~/.scoder/skills/<name>/SKILL.md   (global, user-level)
+ *   2. <workdir>/.scoder/skills/<name>/SKILL.md (project-local)
+ *
+ * Skills are advertised to the model in the system prompt (name + description)
+ * so it can request one explicitly; users can also load one directly via
+ * `/skill <name>`. Inspired by the SKILL.md convention, implemented from
+ * scratch — no external dependencies.
+ */
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const SKILL_FILE = "SKILL.md";
+const MAX_SKILL_BODY_CHARS = 20_000;
+/** M5: cảnh báo validate — consumer (Agent/TUI) hiển thị rồi clear. */
+export const skillWarnings = [];
+/** Parse a minimal YAML-lite frontmatter (key: value lines). */
+export function parseFrontmatter(text) {
+    const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(text);
+    if (!m)
+        return { meta: {}, body: text };
+    const meta = {};
+    for (const line of m[1].split(/\r?\n/)) {
+        const kv = /^([a-zA-Z_][\w-]*)\s*:\s*(.*)$/.exec(line.trim());
+        if (kv)
+            meta[kv[1].toLowerCase()] = kv[2].trim().replace(/^["']|["']$/g, "");
+    }
+    return { meta, body: m[2].trim() };
+}
+/** Read one SKILL.md into a Skill record (null when the file is malformed). */
+export function loadSkillFile(path, scope) {
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+    const { meta, body } = parseFrontmatter(text);
+    const name = (meta.name || "").trim() || null;
+    if (!name)
+        return null; // a skill without a usable name is not discoverable
+    // M5: thiếu description → skip + warn (Anthropic convention: description
+    // là bắt buộc — model dùng nó để quyết định khi nào load skill).
+    const description = (meta.description || "").trim();
+    if (!description) {
+        skillWarnings.push({ path, message: `skill "${name}" thiếu description — bỏ qua (thêm description vào frontmatter)` });
+        return null;
+    }
+    const allowedToolsRaw = (meta["allowed-tools"] || "").trim();
+    return {
+        name,
+        description,
+        path,
+        scope,
+        body: body.length > MAX_SKILL_BODY_CHARS ? body.slice(0, MAX_SKILL_BODY_CHARS) + "\n… [truncated]" : body,
+        ...(allowedToolsRaw ? { allowedTools: allowedToolsRaw.split(",").map((t) => t.trim()).filter(Boolean) } : {}),
+        ...(meta.license ? { license: meta.license } : {}),
+        ...(meta["when-to-use"] ? { whenToUse: meta["when-to-use"] } : {}),
+    };
+}
+/** Collect SKILL.md files from one skills root (one level of directories). */
+function scanRoot(root, scope) {
+    if (!existsSync(root))
+        return [];
+    const out = [];
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const file = join(root, entry.name, SKILL_FILE);
+        if (!existsSync(file))
+            continue;
+        const skill = loadSkillFile(file, scope);
+        if (skill)
+            out.push(skill);
+    }
+    return out;
+}
+/** Global skills root — overridable via SCODER_SKILLS for tests. */
+function globalSkillsRoot() {
+    return process.env.SCODER_SKILLS || join(homedir(), ".scoder", "skills");
+}
+/** Discover all skills visible to a project: global first, project overrides. */
+export function discoverSkills(workdir) {
+    const global = scanRoot(globalSkillsRoot(), "global");
+    const project = scanRoot(join(workdir, ".scoder", "skills"), "project");
+    const byName = new Map();
+    for (const s of [...global, ...project]) {
+        // M5: trùng name → warn (project wins per merge order).
+        if (byName.has(s.name)) {
+            skillWarnings.push({ path: s.path, message: `skill "${s.name}" trùng tên (${s.scope} overrides ${byName.get(s.name)?.scope})` });
+        }
+        byName.set(s.name, s); // project wins
+    }
+    return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+/** Find one skill by (case-insensitive) name, or null. */
+export function findSkill(workdir, name) {
+    const wanted = name.toLowerCase();
+    return discoverSkills(workdir).find((s) => s.name.toLowerCase() === wanted) ?? null;
+}
+/**
+ * One-line-per-skill advertisement for the system prompt — the model sees
+ * names + descriptions and can ask to load a skill, or the user invokes
+ * `/skill <name>` directly.
+ */
+export function formatSkillIndex(skills) {
+    if (skills.length === 0)
+        return "";
+    return skills.map((s) => `- ${s.name}: ${s.description || "(no description)"}`).join("\n");
+}