@njeybe/nativ 2.4.0 → 2.5.0

package/dist/server/routes/worktree-routes.js

@@ -0,0 +1,144 @@
+import { execFile } from 'node:child_process';
+import fs from 'node:fs';
+import { CircuitBreaker } from '../../governor/index.js';
+import { runWorktreeMerge, runWorktreeRemove } from '../../commands/worktree.js';
+import { HttpError } from '../http-utils.js';
+import { parseTaskId, planMilestones, readPlan } from '../plan-utils.js';
+import { jsonErrorMessage, runCaptured, truncateOutput } from '../cli-runner.js';
+export function git(cwd, args) {
+    return new Promise((resolve, reject) => {
+        execFile('git', args, { cwd, timeout: 10_000, windowsHide: true, maxBuffer: 1024 * 1024 }, (err, stdout) => err ? reject(err) : resolve(stdout));
+    });
+}
+/** `git diff --no-index` exits 1 when the inputs differ, so stdout is also read from that "error". */
+export function gitNoIndexDiff(cwd, file) {
+    return new Promise((resolve) => {
+        execFile('git', ['diff', '--no-index', '--', '/dev/null', file], { cwd, timeout: 10_000, windowsHide: true, maxBuffer: 1024 * 1024 }, (err, stdout) => resolve(!err || err.code === 1 ? String(stdout) : ''));
+    });
+}
+/** Async twin of `nativ worktree list --json` (which blocks on execSync and prints to the console). */
+export async function listGitWorktrees(root) {
+    let raw;
+    try {
+        raw = await git(root, ['worktree', 'list', '--porcelain']);
+    }
+    catch {
+        return []; // Not a git repository, or git is unavailable.
+    }
+    const worktrees = [];
+    for (const block of raw.trim().split(/\r?\n\r?\n/)) {
+        let wtPath = '';
+        let head = '';
+        let branch = '';
+        for (const line of block.split(/\r?\n/)) {
+            if (line.startsWith('worktree '))
+                wtPath = line.slice(9).trim();
+            else if (line.startsWith('HEAD '))
+                head = line.slice(5).trim();
+            else if (line.startsWith('branch '))
+                branch = line.slice(7).trim().replace(/^refs\/heads\//, '');
+        }
+        if (!wtPath)
+            continue;
+        worktrees.push({
+            path: wtPath,
+            head,
+            branch: branch || 'detached',
+            isAgentWorktree: wtPath.includes('.worktrees') || branch.startsWith('agent/task-'),
+            taskId: /^agent\/task-(.+)$/.exec(branch)?.[1],
+        });
+    }
+    return worktrees;
+}
+/**
+ * GET /api/pipeline/worktrees. Merge eligibility mirrors the `nativ worktree merge` gatekeeper (task completed,
+ * circuit breaker not tripped), and additionally requires the task to be declared in the plan.
+ */
+export async function describeWorktrees(root) {
+    const statusById = new Map(planMilestones(readPlan(root)).flatMap((m) => m.tasks.map((t) => [t.id, t.status])));
+    return (await listGitWorktrees(root)).map((wt) => {
+        const taskStatus = (wt.taskId && statusById.get(wt.taskId)) || null;
+        let mergeBlockedReason = null;
+        if (!wt.isAgentWorktree || !wt.taskId)
+            mergeBlockedReason = 'Not an agent task worktree';
+        else if (!taskStatus)
+            mergeBlockedReason = `Task "${wt.taskId}" is not declared in .ai/master_plan.json`;
+        else if (taskStatus !== 'completed')
+            mergeBlockedReason = `Task status is '${taskStatus}'; only completed tasks may be merged`;
+        else if (CircuitBreaker.getStatus(root, wt.taskId).tripped)
+            mergeBlockedReason = 'Circuit breaker is tripped; resolve the escalation before merging';
+        return { ...wt, taskStatus, mergeEligible: mergeBlockedReason === null, mergeBlockedReason };
+    });
+}
+/** POST /api/pipeline/worktrees/action: `nativ worktree merge|remove`, never forced past the merge gatekeeper. */
+export async function handleWorktreeAction(root, body) {
+    const { action } = body;
+    if (action !== 'merge' && action !== 'remove')
+        throw new HttpError(400, 'VALIDATION_ERROR', '"action" must be one of: merge, remove');
+    const taskId = parseTaskId(body.taskId);
+    const worktree = (await describeWorktrees(root)).find((wt) => wt.isAgentWorktree && wt.taskId === taskId);
+    if (!worktree)
+        throw new HttpError(400, 'WORKTREE_NOT_FOUND', `No agent worktree found for task "${taskId}"`);
+    if (action === 'merge' && !worktree.mergeEligible) {
+        throw new HttpError(400, 'MERGE_REJECTED', worktree.mergeBlockedReason ?? 'Merge rejected by the gatekeeper');
+    }
+    const { result, failed, output } = await runCaptured(() => action === 'merge' ? runWorktreeMerge(taskId, root, { json: true }) : runWorktreeRemove(taskId, root, { json: true }));
+    if (failed || !result) {
+        throw new HttpError(400, 'WORKTREE_ACTION_FAILED', jsonErrorMessage(output) ?? truncateOutput(output || `Worktree ${action} failed`));
+    }
+    return { ok: true, message: result.message };
+}
+/** GET /api/pipeline/worktrees/diff: uncommitted changes and unified diff for an agent worktree. */
+export async function handleWorktreeDiff(root, searchParams) {
+    const rawTaskId = searchParams.get('taskId');
+    if (!rawTaskId)
+        throw new HttpError(400, 'VALIDATION_ERROR', '"taskId" query parameter is required');
+    const taskId = parseTaskId(rawTaskId);
+    const worktree = (await describeWorktrees(root)).find((wt) => wt.isAgentWorktree && wt.taskId === taskId);
+    if (!worktree || !fs.existsSync(worktree.path)) {
+        throw new HttpError(400, 'WORKTREE_NOT_FOUND', `No agent worktree found for task "${taskId}"`);
+    }
+    let statusOut;
+    try {
+        // -z keeps paths unquoted and unambiguous; -uall lists the files inside untracked directories.
+        statusOut = await git(worktree.path, ['status', '--porcelain', '-z', '--untracked-files=all']);
+    }
+    catch {
+        throw new HttpError(400, 'WORKTREE_INVALID', `Failed to read git status in the worktree for task "${taskId}"`);
+    }
+    const filesChanged = [];
+    const untracked = [];
+    const entries = statusOut.split('\0');
+    for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i];
+        if (entry.length < 4)
+            continue;
+        const xy = entry.slice(0, 2);
+        const file = entry.slice(3);
+        filesChanged.push(file);
+        if (xy === '??')
+            untracked.push(file);
+        // Renames and copies carry the original path in the next field.
+        if (xy[0] === 'R' || xy[0] === 'C')
+            i++;
+    }
+    let diff = '';
+    try {
+        diff = await git(worktree.path, ['diff', 'HEAD']);
+    }
+    catch {
+        diff = await git(worktree.path, ['diff']).catch(() => '');
+    }
+    // `git diff HEAD` skips untracked files; render them as additions without touching the index.
+    for (const file of untracked) {
+        diff += (await gitNoIndexDiff(worktree.path, file)) || `+++ b/${file} (untracked)\n`;
+    }
+    return {
+        ok: true,
+        taskId,
+        branch: worktree.branch,
+        hasChanges: filesChanged.length > 0,
+        filesChanged,
+        diff: diff.trim(),
+    };
+}

package/dist/server/studio-server.d.ts

@@ -1,15 +1,11 @@
 import http from 'node:http';
-import type { DatabaseEnv, DatabaseStatus, TableSchema } from '../db/types.js';
+import type { DatabaseEnv } from '../db/types.js';
 import { type Tier1LiaisonOptions } from '../core/tier1-liaison.js';
 import { type AgentSupervisorOptions } from '../runner/agent-supervisor.js';
-/**
- * Embedded Studio HTTP server (native node:http).
- * Serves the REST endpoints from .ai/api_contracts.json plus the dashboard page.
- *
- * Air-gap rules: binds to loopback only, keeps raw connection URLs in this process's
- * memory, and only ever returns masked URLs in responses.
- */
 export declare const DEFAULT_STUDIO_PORT = 4983;
+export { DEFAULT_HEARTBEAT_MS, PipelineEventHub } from './event-hub.js';
+export { writeContractSchema } from './routes/db-routes.js';
+export { HttpError } from './http-utils.js';
 export interface StudioServerOptions {
     port?: number;
     host?: string;
@@ -31,9 +27,6 @@ export interface StudioServerHandle {
     port: number;
     close(): Promise<void>;
 }
-/** Writes structure-only table metadata into .ai/db_schema.json, preserving other contract fields. */
-export declare function writeContractSchema(cwd: string, status: DatabaseStatus, tables: TableSchema[]): string;
-export declare const DEFAULT_HEARTBEAT_MS = 15000;
 export declare function createStudioServer(options?: StudioServerOptions): http.Server;
 /** Starts the studio on loopback, trying up to 10 consecutive ports if the preferred one is busy. */
 export declare function startStudioServer(options?: StudioServerOptions): Promise<StudioServerHandle>;