@repo-os/repoos 0.5.45

package/dist/server/live-index.js

@@ -0,0 +1,452 @@
+/**
+ * The live index. Stage 1's indexer rebuilds everything from disk on demand;
+ * for a long-lived server that's wasteful and loses the "what changed" signal.
+ *
+ * LiveIndex holds the parsed tasks in memory, applies INCREMENTAL updates when
+ * individual files change, and emits typed events describing each change. It is
+ * still backed entirely by the files on disk — it is a cache with a heartbeat,
+ * never a source of truth. A full rebuild (`refreshAll`) is always available
+ * and always correct.
+ */
+import { readFileSync, existsSync, realpathSync } from "node:fs";
+import { join, extname } from "node:path";
+import { STATUSES, PRIORITIES } from "../core/types.js";
+import { parseTask } from "../core/task.js";
+import { isGitRepo, localBranches, lastCommitForFile, worktreeStatus, worktreePaths, worktreeList, currentBranch, emptyGitInfo, resolveWorktreeStatuses, } from "../core/git.js";
+import { buildIndex, buildIndexAsync, readWorktreeDirtyCache, writeWorktreeDirtyCache, } from "../core/indexer.js";
+import { patchTaskFile } from "./write.js";
+function priorityRank(p) {
+    const i = PRIORITIES.indexOf(p);
+    return i === -1 ? PRIORITIES.length : i;
+}
+function statusRank(s) {
+    return STATUSES.indexOf(s);
+}
+export class LiveIndex {
+    config;
+    /** task id -> Task */
+    byId = new Map();
+    /** abs path -> task id, so a file change maps back to a task */
+    pathToId = new Map();
+    listeners = new Set();
+    useGit = false;
+    branchCache = new Set();
+    /**
+     * Guard invoked by `applyFileChange` for a transition INTO `review` that
+     * did not already pass through the trusted PATCH route. #0210: a direct
+     * task-file edit must be held to the same commit/vacuity gate as the trusted
+     * handoff path. Returns false to reject the transition (the file is reverted
+     * to its previous status); true/fire-and-forget to accept it.
+     */
+    reviewGuard = null;
+    /** Wire the #0210 review-transition guard. The server owns the logic. */
+    setReviewGuard(fn) {
+        this.reviewGuard = fn;
+    }
+    constructor(config) {
+        this.config = config;
+    }
+    /** Build from scratch. Safe to call any time; always authoritative. */
+    refreshAll() {
+        const idx = buildIndex(this.config);
+        this.byId.clear();
+        this.pathToId.clear();
+        this.useGit = isGitRepo(this.config.root);
+        this.branchCache = this.useGit ? localBranches(this.config.root) : new Set();
+        for (const t of idx.tasks) {
+            this.byId.set(t.id, t);
+            this.pathToId.set(t.absPath, t.id);
+        }
+        this.emit({
+            type: "index.rebuilt",
+            taskCount: this.byId.size,
+            at: now(),
+        });
+    }
+    /**
+     * Async counterpart of `refreshAll`, used only at server startup: it lets
+     * `listen()` proceed while the (git-heavy, otherwise multi-second with
+     * 200+ tasks) index build runs in the background — see `buildIndexAsync`.
+     * Not a drop-in replacement for `refreshAll` in general: a file-watcher
+     * update landing mid-build is overwritten by this call's final swap-in,
+     * same as it would be by a concurrent `refreshAll`, but this call's window
+     * is wider. Fine for the one-shot boot case; callers that need to
+     * interleave safely with live updates should keep using `refreshAll`.
+     */
+    async refreshAllAsync() {
+        const idx = await buildIndexAsync(this.config, { fastWorktreeStatus: true });
+        this.byId.clear();
+        this.pathToId.clear();
+        this.useGit = isGitRepo(this.config.root);
+        this.branchCache = this.useGit ? localBranches(this.config.root) : new Set();
+        for (const t of idx.tasks) {
+            this.byId.set(t.id, t);
+            this.pathToId.set(t.absPath, t.id);
+        }
+        this.emit({
+            type: "index.rebuilt",
+            taskCount: this.byId.size,
+            at: now(),
+        });
+        // NOTE: `fastWorktreeStatus` skipped `git status`, so `git.dirty` reflects
+        // only each branch's ahead count until the server's post-listen
+        // `reconcileWorktreeStatus()` sweep fills in the working-tree state. That
+        // sweep is scheduled by the caller, deliberately NOT here — starting git
+        // subprocesses from inside the boot path is exactly what this async build
+        // exists to avoid.
+    }
+    /**
+     * Refresh every task's worktree `dirty`/`worktreePath` with a real
+     * `git status` sweep (batched — see `resolveWorktreeStatuses`), persist the
+     * result, and emit `task.updated` for any that changed. Called after the
+     * fast boot build and safe to call periodically. No-op without git.
+     */
+    async reconcileWorktreeStatus() {
+        if (!this.useGit)
+            return;
+        const baseBranch = currentBranch(this.config.root);
+        const branches = [...this.byId.values()].map((t) => t.branch).filter((b) => !!b);
+        const { statuses, cache, changed } = await resolveWorktreeStatuses(this.config.root, branches, {
+            baseBranch,
+            cache: readWorktreeDirtyCache(this.config),
+        });
+        if (changed)
+            writeWorktreeDirtyCache(this.config, cache);
+        for (const [id, t] of this.byId) {
+            if (!t.branch)
+                continue;
+            const wt = statuses.get(t.branch);
+            if (!wt)
+                continue;
+            if (t.git.dirty === wt.dirty && t.git.worktreePath === wt.path)
+                continue;
+            const next = {
+                ...t,
+                git: { ...t.git, dirty: wt.dirty, worktreePath: wt.path },
+            };
+            this.byId.set(id, next);
+            this.emit({ type: "task.updated", task: next, prev: {}, at: now() });
+        }
+    }
+    isTaskFile(absPath) {
+        const workRoot = join(this.config.root, this.config.workDir);
+        if (!absPath.startsWith(workRoot))
+            return false;
+        return this.config.taskExtensions.includes(extname(absPath));
+    }
+    /**
+     * Re-parse a single file after a create/modify. Emits created or updated.
+     *
+     * `opts.guarded` marks a change that already passed the #0210 review gate
+     * (the trusted PATCH route and the trusted handoff path run the gate
+     * themselves), so it is applied synchronously without re-invoking the guard.
+     * Unmarked transitions INTO `review` — a direct task-file edit picked up by
+     * the watcher — are deferred to the async guard, which reverts the file to
+     * its previous status if the transition is rejected. Returns a Promise for
+     * that deferred case so callers (and tests) can await its settlement.
+     */
+    applyFileChange(absPath, opts = {}) {
+        if (!this.isTaskFile(absPath))
+            return;
+        if (!existsSync(absPath)) {
+            this.applyFileDelete(absPath);
+            return;
+        }
+        let content;
+        try {
+            content = readFileSync(absPath, "utf8");
+        }
+        catch {
+            return; // transient read error (editor mid-write); next event will catch it
+        }
+        const task = parseTask({
+            content,
+            absPath,
+            root: this.config.root,
+            defaultStatus: this.config.defaultStatus,
+            defaultAssignee: this.config.defaultAssignee,
+            git: emptyGitInfo(),
+        });
+        if (this.useGit) {
+            const { subject, date } = lastCommitForFile(this.config.root, task.path);
+            const wt = task.branch
+                ? worktreeStatus(this.config.root, task.branch)
+                : { path: null, dirty: false };
+            task.git = {
+                branchExists: task.branch ? this.branchCache.has(task.branch) : false,
+                worktreeExists: task.branch ? worktreePaths(this.config.root).has(task.branch) : false,
+                lastCommit: subject,
+                lastCommitAt: date,
+                worktreePath: wt.path,
+                dirty: wt.dirty,
+            };
+        }
+        const existing = this.byId.get(task.id);
+        // If the id moved to a different file, treat the old path as stale.
+        const priorPath = [...this.pathToId.entries()].find(([, id]) => id === task.id)?.[0];
+        if (priorPath && priorPath !== absPath)
+            this.pathToId.delete(priorPath);
+        // #0210: a transition INTO `review` that did not already pass through the
+        // trusted PATCH/handoff paths must be held to the same commit/vacuity gate
+        // before the index reflects it. Defer so a rejected transition never
+        // surfaces as a review event (no misleading auto-review/preview launch).
+        if (!opts.guarded &&
+            this.reviewGuard &&
+            existing &&
+            existing.status !== "review" &&
+            task.status === "review") {
+            return this.runReviewGuard(absPath, task, existing);
+        }
+        this.applyParsed(absPath, task, existing);
+    }
+    /** Apply a fully-parsed task to the in-memory index and emit. */
+    applyParsed(absPath, task, existing) {
+        this.byId.set(task.id, task);
+        this.pathToId.set(absPath, task.id);
+        if (!existing) {
+            this.emit({ type: "task.created", task, at: now() });
+        }
+        else {
+            const prev = diff(existing, task);
+            // Only emit if something user-visible actually changed.
+            if (Object.keys(prev).length > 0) {
+                this.emit({ type: "task.updated", task, prev, at: now() });
+            }
+        }
+    }
+    /**
+     * Run the #0210 review guard for a deferred transition into `review`. On
+     * acceptance the task is applied normally (the worktree was committed by the
+     * guard). On rejection the task file is reverted to its previous status —
+     * using the same safe write path as a server edit — so the bypass can never
+     * leave a task sitting in `review` with uncommitted work.
+     */
+    async runReviewGuard(absPath, task, existing) {
+        if (!this.reviewGuard) {
+            this.applyParsed(absPath, task, existing);
+            return;
+        }
+        let allowed;
+        try {
+            allowed = await this.reviewGuard(task, existing);
+        }
+        catch {
+            allowed = false; // a failing guard must not leak the transition through
+        }
+        if (!allowed) {
+            try {
+                patchTaskFile(this.config, absPath, { status: existing.status });
+            }
+            catch {
+                // If the revert fails, reflect what git actually shows rather than the
+                // unvalidated review state.
+            }
+            // Re-read whatever is now on disk (reverted, or unchanged) and apply it.
+            if (!existsSync(absPath))
+                return;
+            this.applyFileChange(absPath, { guarded: true });
+            return;
+        }
+        this.applyParsed(absPath, task, existing);
+    }
+    /** Handle a file removal. Emits deleted if it mapped to a known task. */
+    applyFileDelete(absPath) {
+        const id = this.pathToId.get(absPath);
+        if (!id)
+            return;
+        const task = this.byId.get(id);
+        this.pathToId.delete(absPath);
+        this.byId.delete(id);
+        this.emit({
+            type: "task.deleted",
+            id,
+            path: task?.path ?? absPath,
+            at: now(),
+        });
+    }
+    /**
+     * Re-scan local branches / worktrees and re-apply the cheap git facts
+     * (`branchExists`, `worktreeExists`, `worktreePath`) to every indexed task.
+     * Called after an agent launch, branch sync, or hotfix so the UI's branch/
+     * worktree dots are right without a full rebuild.
+     *
+     * `dirty` is NOT recomputed here — that needs a `git status` per worktree,
+     * which this method used to run synchronously for every task on the event
+     * loop (~2.5s at 40 worktrees, on every task mutation). It is delegated to
+     * the batched `reconcileWorktreeStatus()` sweep, kicked off below and
+     * arriving via `task.updated` within ~100ms.
+     */
+    refreshBranches() {
+        this.useGit = isGitRepo(this.config.root);
+        this.branchCache = this.useGit ? localBranches(this.config.root) : new Set();
+        const worktrees = this.useGit
+            ? worktreeList(this.config.root)
+            : new Map();
+        let realRoot = this.config.root;
+        try {
+            realRoot = realpathSync(this.config.root);
+        }
+        catch {
+            /* keep the configured root */
+        }
+        for (const [id, t] of this.byId) {
+            let worktreePath = t.branch ? (worktrees.get(t.branch)?.path ?? null) : null;
+            if (worktreePath) {
+                let rp = worktreePath;
+                try {
+                    rp = realpathSync(worktreePath);
+                }
+                catch {
+                    /* keep the reported path */
+                }
+                // git lists the main checkout as a worktree too; it is never a task one.
+                if (rp === realRoot)
+                    worktreePath = null;
+            }
+            this.byId.set(id, {
+                ...t,
+                git: {
+                    ...t.git,
+                    branchExists: t.branch ? this.branchCache.has(t.branch) : false,
+                    worktreeExists: t.branch ? worktrees.has(t.branch) : false,
+                    worktreePath,
+                },
+            });
+        }
+        void this.reconcileWorktreeStatus();
+    }
+    // ---- reads ----
+    getTasks(status) {
+        const all = [...this.byId.values()];
+        const filtered = status ? all.filter((t) => t.status === status) : all;
+        return filtered.sort((a, b) => {
+            const s = statusRank(a.status) - statusRank(b.status);
+            if (s !== 0)
+                return s;
+            const p = priorityRank(a.priority) - priorityRank(b.priority);
+            if (p !== 0)
+                return p;
+            return a.id.localeCompare(b.id);
+        });
+    }
+    getTask(id) {
+        return this.byId.get(id) ?? null;
+    }
+    counts() {
+        const c = Object.fromEntries(STATUSES.map((s) => [s, 0]));
+        for (const t of this.byId.values())
+            c[t.status]++;
+        return c;
+    }
+    snapshot() {
+        const tasks = this.getTasks();
+        return {
+            version: 1,
+            generatedAt: now(),
+            root: this.config.root,
+            taskCount: tasks.length,
+            tasks,
+            counts: this.counts(),
+        };
+    }
+    /** Lightweight board snapshot — skips body, extra, agent overrides. */
+    boardSnapshot() {
+        const tasks = this.getTasks();
+        return {
+            version: 1,
+            generatedAt: now(),
+            root: this.config.root,
+            taskCount: tasks.length,
+            tasks: tasks.map(toBoardTask),
+            counts: this.counts(),
+        };
+    }
+    // ---- events ----
+    on(fn) {
+        this.listeners.add(fn);
+        return () => this.listeners.delete(fn);
+    }
+    emit(e) {
+        for (const fn of this.listeners) {
+            try {
+                fn(e);
+            }
+            catch {
+                /* a bad listener must not break the index */
+            }
+        }
+    }
+}
+function now() {
+    return new Date().toISOString();
+}
+/** Strip a Task down to what the board renders. */
+function toBoardTask(t) {
+    return {
+        id: t.id,
+        title: t.title,
+        type: t.type,
+        status: t.status,
+        needsInput: t.needsInput,
+        needsInputReason: t.needsInputReason,
+        needsMerge: t.needsMerge,
+        priority: t.priority,
+        area: t.area,
+        assignee: t.assignee,
+        assignedTo: t.assignedTo,
+        createdBy: t.createdBy,
+        branch: t.branch,
+        tags: t.tags,
+        created_at: t.created_at,
+        updated_at: t.updated_at,
+        releasedAt: t.releasedAt ?? null,
+        bodyPreview: t.body?.slice(0, 500) ?? "",
+        path: t.path,
+        absPath: t.absPath,
+        git: t.git,
+        preview: null,
+        checkRetryCount: typeof t.extra?.check_retry_count === "number" ? t.extra.check_retry_count : 0,
+        mergeConflictRetryCount: typeof t.extra?.merge_conflict_retry_count === "number"
+            ? t.extra.merge_conflict_retry_count
+            : 0,
+        handoffSignalRetryCount: typeof t.extra?.handoff_signal_retry_count === "number"
+            ? t.extra.handoff_signal_retry_count
+            : 0,
+    };
+}
+/** Shallow diff of the fields we care about, for the `prev` payload. */
+function diff(a, b) {
+    const fields = [
+        "title",
+        "status",
+        "priority",
+        "area",
+        "assignee",
+        "assignedTo",
+        "branch",
+        "type",
+        "needsInput",
+        "needsInputReason",
+        "needsMerge",
+        "agentOverride",
+        "cliOverride",
+        "modelOverride",
+        "pmAgentOverride",
+        "pmCliOverride",
+        "pmModelOverride",
+        "reviewAgentOverride",
+        "reviewCliOverride",
+        "reviewModelOverride",
+        "created_at",
+        "updated_at",
+    ];
+    const out = {};
+    for (const f of fields) {
+        if (a[f] !== b[f])
+            out[f] = a[f];
+    }
+    // body change is common and worth signalling, but don't ship the whole body
+    if (a.body !== b.body)
+        out.body = "(changed)";
+    return out;
+}

package/dist/server/model-test.d.ts

@@ -0,0 +1,20 @@
+import type { ModelSourceResult } from "../core/models.js";
+export declare const MODEL_TEST_SENTINEL = "REPOOS_MODEL_OK";
+export declare const MODEL_TEST_TIMEOUT_MS = 8000;
+export type ModelTestStatus = "passed" | "failed" | "timed_out" | "not_testable";
+export interface ModelTestResult {
+    cli: string;
+    model: string;
+    status: ModelTestStatus;
+    durationMs: number;
+    error?: string;
+}
+export interface ModelTestOptions {
+    cwd: string;
+    timeoutMs?: number;
+    concurrency?: number;
+}
+export declare function sanitizeDiagnostic(text: string): string;
+export declare function testModelCombination(cli: string, model: string, opts: ModelTestOptions): Promise<ModelTestResult>;
+/** Test supported per-CLI model sources with a bounded worker pool. */
+export declare function testModelCombinations(byCli: Record<string, ModelSourceResult>, opts: ModelTestOptions): Promise<ModelTestResult[]>;

package/dist/server/model-test.js

@@ -0,0 +1,100 @@
+import { spawn } from "node:child_process";
+import { promptCommand } from "./agents.js";
+export const MODEL_TEST_SENTINEL = "REPOOS_MODEL_OK";
+export const MODEL_TEST_TIMEOUT_MS = 8_000;
+const OUTPUT_LIMIT = 4 * 1024;
+export function sanitizeDiagnostic(text) {
+    return text
+        .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+        .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "")
+        .trim()
+        .slice(0, OUTPUT_LIMIT);
+}
+export function testModelCombination(cli, model, opts) {
+    const started = Date.now();
+    const finish = (status, error) => ({
+        cli,
+        model,
+        status,
+        durationMs: Date.now() - started,
+        ...(error ? { error: sanitizeDiagnostic(error) } : {}),
+    });
+    const agent = { name: "model-test", cli, model, enabled: true };
+    const { cmd, args } = promptCommand(agent, `Reply with exactly ${MODEL_TEST_SENTINEL}. Do not use tools or modify files.`);
+    // Compatibility probes may run from a configured repo root that Codex has
+    // not marked trusted yet. The prompt cannot modify files, so bypass only the
+    // repository trust preflight for this disposable probe.
+    if (cli === "codex")
+        args.splice(1, 0, "--skip-git-repo-check");
+    return new Promise((resolve) => {
+        let proc;
+        try {
+            proc = spawn(cmd, args, { cwd: opts.cwd, stdio: ["ignore", "pipe", "pipe"] });
+        }
+        catch (err) {
+            resolve(finish("failed", err instanceof Error ? err.message : String(err)));
+            return;
+        }
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const done = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(result);
+        };
+        const timer = setTimeout(() => {
+            try {
+                proc.kill("SIGKILL");
+            }
+            catch {
+                /* already exited */
+            }
+            done(finish("timed_out", `Timed out after ${opts.timeoutMs ?? MODEL_TEST_TIMEOUT_MS}ms`));
+        }, opts.timeoutMs ?? MODEL_TEST_TIMEOUT_MS);
+        proc.stdout?.on("data", (chunk) => {
+            if (stdout.length < OUTPUT_LIMIT)
+                stdout += chunk.toString("utf8");
+        });
+        proc.stderr?.on("data", (chunk) => {
+            if (stderr.length < OUTPUT_LIMIT)
+                stderr += chunk.toString("utf8");
+        });
+        proc.on("error", (err) => done(finish("failed", `Could not launch ${cmd}: ${err.message}`)));
+        proc.on("close", (code) => {
+            if (code === 0 && sanitizeDiagnostic(stdout).includes(MODEL_TEST_SENTINEL)) {
+                done(finish("passed"));
+            }
+            else {
+                const detail = stderr || stdout || `${cmd} exited with code ${code ?? "unknown"}`;
+                done(finish("failed", detail));
+            }
+        });
+    });
+}
+/** Test supported per-CLI model sources with a bounded worker pool. */
+export async function testModelCombinations(byCli, opts) {
+    const queued = [];
+    const results = [];
+    for (const [cli, source] of Object.entries(byCli)) {
+        const models = [...new Set(source.models.length ? source.models : ["default"])];
+        if (!source.supported) {
+            for (const model of models)
+                results.push({ cli, model, status: "not_testable", durationMs: 0 });
+            continue;
+        }
+        for (const model of models)
+            queued.push({ cli, model });
+    }
+    let next = 0;
+    const workers = Array.from({ length: Math.min(Math.max(1, opts.concurrency ?? 2), queued.length) }, async () => {
+        while (next < queued.length) {
+            const item = queued[next++];
+            results.push(await testModelCombination(item.cli, item.model, opts));
+        }
+    });
+    await Promise.all(workers);
+    return results.sort((a, b) => a.cli.localeCompare(b.cli) || a.model.localeCompare(b.model));
+}

package/dist/server/ntfy.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Optional ntfy push notifications for task lifecycle events (#0161).
+ *
+ * Redesigned to be scannable one-line notifications using the grammar:
+ * [emoji] [short human event] · [task title]
+ *
+ * Fire-and-forget HTTP POSTs to a ntfy topic. Best-effort by design: a network
+ * error, bad topic, or offline server must never block or fail the status
+ * transition that triggered the notification — callers just call
+ * `notifyStatusChange` and ignore the result.
+ *
+ * No runtime dependencies: publishing uses the platform's native `fetch`
+ * (Node >= 18 / Bun). If the topic is empty or the toggle is off, nothing is
+ * ever sent.
+ */
+import type { RepoOSConfig, Status, Task } from "../core/types.js";
+type NotificationPriority = "min" | "low" | "default" | "high" | "max";
+interface NotificationSpec {
+    /** Emoji + short verb, e.g. "▶️ Started" */
+    headline: string;
+    /** ntfy priority header: "Needs you", "Blocked", "Failed" = high/max; "Done", "Started" = low */
+    priority: NotificationPriority;
+    /** Optional second line for "Needs you" notifications, e.g. "Agent is waiting for your decision" */
+    subtitle?: string;
+}
+/** The ntfy server base URL: env var wins, then config, then the default. */
+export declare function ntfyBaseUrl(config: RepoOSConfig): string;
+/**
+ * Build a notification spec for a status transition, or null if no notification applies.
+ * For ready → active, returns "Started" (lower priority to avoid noise).
+ * For active/review → done, returns "Done" (lower priority).
+ * Other transitions do not currently trigger notifications.
+ */
+export declare function notificationForStatusChange(prev: Status, next: Status): NotificationSpec | null;
+/**
+ * Build a notification spec for task creation.
+ * Returns "New" with low priority (informational).
+ */
+export declare function notificationForTaskCreated(): NotificationSpec;
+/**
+ * Build a notification spec when a task needs human input.
+ * Returns "Needs you" with high priority and a subtitle explaining the situation.
+ */
+export declare function notificationForNeedsInput(): NotificationSpec;
+/** Format a notification spec into the final message string. */
+export declare function formatNotification(spec: NotificationSpec, title: string): string;
+/** True when notifications are enabled AND a topic is configured. */
+export declare function shouldSend(config: RepoOSConfig): boolean;
+/** Best-effort publish of a message to the configured topic. Never throws. */
+export declare function publish(config: RepoOSConfig, message: string, priority?: NotificationPriority): void;
+/** Fire a notification for a task status transition, if one applies. */
+export declare function notifyStatusChange(config: RepoOSConfig, task: Task, prev: Status, next: Status): void;
+/** Fire a notification when a task is created (stretch from #0134). */
+export declare function notifyTaskCreated(config: RepoOSConfig, task: Task): void;
+/** Fire a notification when a task needs human input. */
+export declare function notifyNeedsInput(config: RepoOSConfig, task: Task): void;
+export {};