s-app-scoder-agent 0.5.0 → 0.7.0

package/dist/snapshot.js

@@ -0,0 +1,170 @@
+/**
+ * Snapshot & undo — git shadow repository (H-11).
+ *
+ * Source: anomalyco/opencode (packages/core/src/snapshot.ts) — pattern
+ * adapted: a separate git directory under .scoder/snapshot/ shares the
+ * project worktree; each write-batch captures a checkpoint commit. `git`
+ * binary required; best-effort (failures never crash the run).
+ *
+ * Layout: .scoder/snapshot/ (GIT_DIR, bare-ish) + checkpoint log in memory.
+ * Restore: `git checkout <tree> -- .` onto the worktree via the shadow.
+ */
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";
+import { join, resolve } from "node:path";
+/** True when `git` is on PATH and the workdir is inside a git repo (or can be). */
+function gitAvailable(workdir) {
+    const r = spawnSync("git", ["rev-parse", "--git-dir"], { cwd: workdir, encoding: "utf8" });
+    return r.status === 0;
+}
+export class SnapshotManager {
+    gitDir;
+    workdir;
+    enabled;
+    checkpoints = [];
+    initialized = false;
+    available = false;
+    /** Set when the project has no .git — fallback: no-op (copy-tree skipped, see ponytail). */
+    degradedReason = null;
+    constructor(workdir, enabled) {
+        this.workdir = resolve(workdir);
+        this.gitDir = join(this.workdir, ".scoder", "snapshot");
+        this.enabled = enabled;
+        if (!enabled) {
+            this.degradedReason = null;
+            return;
+        }
+        try {
+            if (!gitAvailable(this.workdir)) {
+                this.degradedReason = "git binary unavailable or not a repo — snapshots disabled (fallback copy-tree not enabled)";
+                return;
+            }
+            mkdirSync(this.gitDir, { recursive: true });
+            this.available = true;
+        }
+        catch (err) {
+            this.degradedReason = err.message;
+        }
+    }
+    /** Lazily init the shadow repo (first capture only). */
+    init() {
+        if (this.initialized)
+            return this.available;
+        this.initialized = true;
+        if (!this.available)
+            return false;
+        const ok = (args) => spawnSync("git", args, { cwd: this.workdir, env: { ...process.env, GIT_DIR: this.gitDir, GIT_WORK_TREE: this.workdir }, encoding: "utf8" });
+        try {
+            if (!existsSync(join(this.gitDir, "HEAD"))) {
+                if (ok(["init", "--quiet", this.gitDir]).status !== 0) {
+                    this.available = false;
+                    return false;
+                }
+            }
+            // Ignore everything except what we track: snapshot repo has its own index.
+            this.available = true;
+            return true;
+        }
+        catch {
+            this.available = false;
+            return false;
+        }
+    }
+    /** Capture current state as a checkpoint. Returns the tree hash or null. */
+    capture(label) {
+        if (!this.enabled || !this.init())
+            return null;
+        const run = (args) => spawnSync("git", args, {
+            cwd: this.workdir,
+            encoding: "utf8",
+            env: { ...process.env, GIT_DIR: this.gitDir, GIT_WORK_TREE: this.workdir },
+        });
+        try {
+            // Add all (shadow index is independent from the project's index).
+            if (run(["add", "-A", "--", ".", ":(exclude).scoder"]).status !== 0)
+                return null;
+            const tree = run(["write-tree"]);
+            if (tree.status !== 0)
+                return null;
+            const hash = tree.stdout.trim();
+            // Empty tree (nothing changed vs previous checkpoint) — still record.
+            const ts = new Date().toISOString();
+            const id = `cp${this.checkpoints.length + 1}-${hash.slice(0, 8)}`;
+            const entry = { id, tree: hash, ts, label };
+            this.checkpoints.push(entry);
+            return entry;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** List checkpoints (newest last). */
+    list() {
+        return [...this.checkpoints];
+    }
+    /**
+     * T-06: diff between two checkpoint trees (or tree vs current worktree
+     * when `to` is null). Returns unified diff text or null.
+     */
+    diff(fromTree, toTree) {
+        if (!this.enabled || !this.init())
+            return null;
+        const run = (args) => spawnSync("git", args, {
+            cwd: this.workdir,
+            encoding: "utf8",
+            env: { ...process.env, GIT_DIR: this.gitDir, GIT_WORK_TREE: this.workdir },
+        });
+        const args = toTree ? ["diff-tree", "-p", fromTree, toTree] : ["diff", fromTree];
+        const r = run(args);
+        if (r.status !== 0 && r.stdout.length === 0)
+            return null;
+        return r.stdout || null;
+    }
+    /** Revert tracked files to a checkpoint tree. Files added after it are deleted. */
+    restore(tree) {
+        if (!this.enabled || !this.init())
+            return false;
+        const run = (args) => spawnSync("git", args, {
+            cwd: this.workdir,
+            encoding: "utf8",
+            env: { ...process.env, GIT_DIR: this.gitDir, GIT_WORK_TREE: this.workdir },
+        });
+        try {
+            // Index → checkpoint tree, then force-checkout all index entries.
+            if (run(["read-tree", tree]).status !== 0)
+                return false;
+            if (run(["checkout-index", "-a", "-f"]).status !== 0)
+                return false;
+            // Delete files present in the workdir but absent from the checkpoint
+            // (checkout-index cannot remove). Diff tree vs workdir via ls-files.
+            const known = run(["ls-tree", "-r", "--name-only", tree]);
+            if (known.status !== 0)
+                return false;
+            const treeFiles = new Set(known.stdout.trim().split("\n").filter(Boolean));
+            const walk = (dir, rel) => {
+                let entries;
+                try {
+                    entries = readdirSync(dir, { withFileTypes: true });
+                }
+                catch {
+                    return;
+                }
+                for (const e of entries) {
+                    if (e.name === ".git" || e.name === ".scoder")
+                        continue;
+                    const abs = join(dir, e.name);
+                    const r = rel ? `${rel}/${e.name}` : e.name;
+                    if (e.isDirectory())
+                        walk(abs, r);
+                    else if (!treeFiles.has(r))
+                        rmSync(abs, { force: true });
+                }
+            };
+            walk(this.workdir, "");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/steering.js

@@ -0,0 +1,35 @@
+/**
+ * I5: Steering inbox tách module — policy delivery tại safe step boundary
+ * (pattern từ opencode session/runner). Thread-safe trong 1 event loop:
+ * push từ TUI/serve, drain ở đầu mỗi step của runLoop. Không rơi message:
+ * drain nguyên batch (FIFO), steer giữa parallel tool calls chờ tới boundary.
+ */
+export class SteeringInbox {
+    items = [];
+    /** Steer: deliver ở NEXT step boundary (kể cả khi đang chạy tool). */
+    steer(text) {
+        const t = text.trim();
+        if (!t)
+            return;
+        this.items.push({ mode: "steer", text: t });
+    }
+    /** Queue: same inbox — caller phân biệt mode chỉ để log/event. */
+    queue(text) {
+        const t = text.trim();
+        if (!t)
+            return;
+        this.items.push({ mode: "queue", text: t });
+    }
+    /** Drain toàn bộ (FIFO) — một batch cho step boundary này. */
+    drain() {
+        const out = this.items;
+        this.items = [];
+        return out;
+    }
+    get size() {
+        return this.items.length;
+    }
+    clear() {
+        this.items = [];
+    }
+}