relay-ide 0.1.0

package/dist/test/belayer-prompts.test.js

@@ -0,0 +1,60 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { buildBrainstormPrompt, buildPlanPrompt, buildExecutionPrompt, buildReviewPrompt, buildStuckPrompt } from '../server/belayer/prompts.js';
+const testTask = {
+    source: 'text',
+    title: 'Add CSV export',
+    description: 'Users should be able to export data as CSV files',
+    acceptanceCriteria: ['Export button visible', 'CSV downloads correctly'],
+};
+test('buildBrainstormPrompt includes task title and description', () => {
+    const prompt = buildBrainstormPrompt(testTask);
+    assert.ok(prompt.includes('Add CSV export'));
+    assert.ok(prompt.includes('export data as CSV files'));
+});
+test('buildBrainstormPrompt includes acceptance criteria when present', () => {
+    const prompt = buildBrainstormPrompt(testTask);
+    assert.ok(prompt.includes('Export button visible'));
+    assert.ok(prompt.includes('CSV downloads correctly'));
+});
+test('buildPlanPrompt includes PRD content', () => {
+    const prompt = buildPlanPrompt(testTask, '# PRD\n## Goals\nExport CSV');
+    assert.ok(prompt.includes('# PRD'));
+    assert.ok(prompt.includes('Export CSV'));
+});
+test('buildExecutionPrompt includes plan content', () => {
+    const prompt = buildExecutionPrompt(testTask, '# Plan\n## Task 1\nCreate export button');
+    assert.ok(prompt.includes('# Plan'));
+    assert.ok(prompt.includes('Create export button'));
+});
+test('buildExecutionPrompt includes verdict feedback on retry', () => {
+    const verdict = {
+        goalName: 'CSV Export',
+        pass: false,
+        criteriaResults: [{ criterion: 'Export works', met: false, reason: 'Button missing' }],
+        summary: 'Export button not found',
+        timestamp: new Date().toISOString(),
+    };
+    const prompt = buildExecutionPrompt(testTask, '# Plan', [verdict]);
+    assert.ok(prompt.includes('PREVIOUS REVIEW FEEDBACK'));
+    assert.ok(prompt.includes('Button missing'));
+});
+test('buildReviewPrompt includes task spec and acceptance criteria', () => {
+    const prompt = buildReviewPrompt(testTask, '/tmp/worktree');
+    assert.ok(prompt.includes('Add CSV export'));
+    assert.ok(prompt.includes('Export button visible'));
+});
+test('buildReviewPrompt instructs verdict.json output', () => {
+    const prompt = buildReviewPrompt(testTask, '/tmp/worktree');
+    assert.ok(prompt.includes('verdict.json'));
+});
+test('buildStuckPrompt includes attempt count and verdicts', () => {
+    const verdicts = [
+        { goalName: 'test', pass: false, criteriaResults: [], summary: 'Failed attempt 1', timestamp: '' },
+        { goalName: 'test', pass: false, criteriaResults: [], summary: 'Failed attempt 2', timestamp: '' },
+    ];
+    const prompt = buildStuckPrompt(testTask, verdicts, 2);
+    assert.ok(prompt.includes('2'));
+    assert.ok(prompt.includes('Failed attempt 1'));
+    assert.ok(prompt.includes('Failed attempt 2'));
+});

package/dist/test/belayer-types.test.js

@@ -0,0 +1,69 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { DEFAULT_PIPELINE_CONFIG, VALID_TRANSITIONS } from '../server/belayer/types.js';
+test('DEFAULT_PIPELINE_CONFIG has expected defaults', () => {
+    assert.deepEqual(DEFAULT_PIPELINE_CONFIG.models, { brainstorm: 'opus', execute: 'opus', review: 'sonnet' });
+    assert.equal(DEFAULT_PIPELINE_CONFIG.maxAttempts, 3);
+    assert.equal(DEFAULT_PIPELINE_CONFIG.autoPush, true);
+    assert.equal(DEFAULT_PIPELINE_CONFIG.targetRepo, '');
+    assert.equal(DEFAULT_PIPELINE_CONFIG.baseBranch, 'main');
+});
+test('VALID_TRANSITIONS covers all states', () => {
+    const allStates = [
+        'intake', 'brainstorming', 'prd_review', 'planning', 'plan_review',
+        'executing', 'reviewing', 'retry', 'stuck', 'pr_created',
+        'ci_monitoring', 'ready_for_review', 'done', 'failed',
+    ];
+    for (const state of allStates) {
+        assert.ok(state in VALID_TRANSITIONS, `Missing transitions for state: ${state}`);
+    }
+});
+test('done state has no valid transitions', () => {
+    assert.deepEqual(VALID_TRANSITIONS.done, []);
+});
+test('all active states can transition to failed', () => {
+    const allStates = Object.keys(VALID_TRANSITIONS);
+    for (const state of allStates) {
+        if (state === 'done' || state === 'failed')
+            continue;
+        assert.ok(VALID_TRANSITIONS[state].includes('failed'), `State ${state} should be able to transition to failed`);
+    }
+});
+test('failed can only transition to intake (restart)', () => {
+    assert.deepEqual(VALID_TRANSITIONS.failed, ['intake']);
+});
+test('TaskSpec type accepts text source', () => {
+    const spec = {
+        source: 'text',
+        title: 'Test task',
+        description: 'A test description',
+    };
+    assert.equal(spec.source, 'text');
+    assert.equal(spec.title, 'Test task');
+});
+test('Pipeline type has correct shape', () => {
+    const pipeline = {
+        id: 'test-id',
+        state: 'intake',
+        task: { source: 'text', title: 'Test', description: 'Desc' },
+        config: DEFAULT_PIPELINE_CONFIG,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        attempts: 0,
+        maxAttempts: 3,
+        verdicts: [],
+    };
+    assert.equal(pipeline.state, 'intake');
+    assert.equal(pipeline.attempts, 0);
+});
+test('Verdict type has correct shape', () => {
+    const verdict = {
+        goalName: 'Feature X',
+        pass: true,
+        criteriaResults: [{ criterion: 'Tests pass', met: true }],
+        summary: 'All good',
+        timestamp: new Date().toISOString(),
+    };
+    assert.equal(verdict.pass, true);
+    assert.equal(verdict.criteriaResults.length, 1);
+});

package/dist/test/bin/claude-remote-cli.js

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import fs from 'node:fs';
+import { execFile, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+import { fileURLToPath } from 'node:url';
+import * as service from '../server/service.js';
+import { DEFAULTS } from '../server/config.js';
+const execFileAsync = promisify(execFile);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+function execErrorMessage(err, fallback) {
+    const e = err;
+    return (e.stderr || e.message || fallback).trimEnd();
+}
+// Parse CLI flags
+const args = process.argv.slice(2);
+if (args.includes('--help') || args.includes('-h')) {
+    console.log(`Usage: claude-remote-cli [options]
+       claude-remote-cli <command>
+
+Commands:
+  update             Update to the latest version from npm
+  install            Install as a background service (survives reboot)
+  uninstall          Stop and remove the background service
+  status             Show whether the service is running
+  worktree           Manage git worktrees (wraps git worktree)
+    add [path] [-b branch] [--yolo]   Create worktree and launch Claude
+    remove <path>                      Forward to git worktree remove
+    list                               Forward to git worktree list
+
+Options:
+  --bg               Shortcut: install and start as background service
+  --port <port>      Override server port (default: 3456)
+  --host <host>      Override bind address (default: 0.0.0.0)
+  --config <path>    Path to config.json (default: ~/.config/claude-remote-cli/config.json)
+  --debug-log        Enable SDK event debug logging to ~/.config/claude-remote-cli/debug/
+  --yolo             With 'worktree add': pass --dangerously-skip-permissions to Claude
+  --version, -v      Show version
+  --help, -h         Show this help`);
+    process.exit(0);
+}
+if (args.includes('--version') || args.includes('-v')) {
+    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '../../package.json'), 'utf-8'));
+    console.log(pkg.version);
+    process.exit(0);
+}
+function getArg(flag) {
+    const idx = args.indexOf(flag);
+    if (idx === -1 || idx + 1 >= args.length)
+        return undefined;
+    return args[idx + 1];
+}
+function resolveConfigPath() {
+    const explicit = getArg('--config');
+    if (explicit)
+        return explicit;
+    return path.join(service.CONFIG_DIR, 'config.json');
+}
+function runServiceCommand(fn) {
+    try {
+        fn();
+    }
+    catch (e) {
+        console.error(e.message);
+        process.exit(1);
+    }
+    process.exit(0);
+}
+const command = args[0];
+if (command === 'update') {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '../../package.json'), 'utf-8'));
+        console.log(`Current version: ${pkg.version}`);
+        console.log('Updating claude-remote-cli...');
+        await execFileAsync('npm', ['install', '-g', 'claude-remote-cli@latest']);
+        const updatedPkg = JSON.parse(fs.readFileSync(path.join(__dirname, '../../package.json'), 'utf-8'));
+        if (updatedPkg.version === pkg.version) {
+            console.log(`Already on the latest version (${pkg.version}).`);
+        }
+        else {
+            console.log(`Updated to ${updatedPkg.version}.`);
+            if (service.isInstalled()) {
+                console.log('Background service detected — restarting...');
+                service.uninstall();
+                service.install({
+                    configPath: resolveConfigPath(),
+                    port: getArg('--port') ?? String(DEFAULTS.port),
+                    host: getArg('--host') ?? DEFAULTS.host,
+                });
+                console.log('Service restarted.');
+            }
+        }
+    }
+    catch (e) {
+        console.error('Update failed:', e.message);
+        process.exit(1);
+    }
+    process.exit(0);
+}
+if (command === 'worktree') {
+    const wtArgs = args.slice(1);
+    const subCommand = wtArgs[0];
+    if (!subCommand) {
+        console.error('Usage: claude-remote-cli worktree <add|remove|list> [options]');
+        process.exit(1);
+    }
+    if (subCommand !== 'add') {
+        try {
+            const result = await execFileAsync('git', ['worktree', ...wtArgs]);
+            if (result.stdout)
+                console.log(result.stdout.trimEnd());
+        }
+        catch (err) {
+            console.error(execErrorMessage(err, 'git worktree failed'));
+            process.exit(1);
+        }
+        process.exit(0);
+    }
+    // Handle 'add' -- strip --yolo, determine path, forward to git, then launch claude
+    const hasYolo = wtArgs.includes('--yolo');
+    const gitWtArgs = wtArgs.filter(function (a) { return a !== '--yolo'; });
+    const addSubArgs = gitWtArgs.slice(1);
+    let targetDir;
+    const bIdx = gitWtArgs.indexOf('-b');
+    const branchForDefault = bIdx !== -1 && bIdx + 1 < gitWtArgs.length ? gitWtArgs[bIdx + 1] : undefined;
+    if (addSubArgs.length === 0 || addSubArgs[0].startsWith('-')) {
+        let repoRoot;
+        try {
+            const result = await execFileAsync('git', ['rev-parse', '--show-toplevel']);
+            repoRoot = result.stdout.trim();
+        }
+        catch {
+            console.error('Not inside a git repository.');
+            process.exit(1);
+        }
+        const dirName = branchForDefault
+            ? branchForDefault.replace(/\//g, '-')
+            : 'worktree-' + Date.now().toString(36);
+        targetDir = path.join(repoRoot, '.worktrees', dirName);
+        gitWtArgs.splice(1, 0, targetDir);
+    }
+    else {
+        targetDir = path.resolve(addSubArgs[0]);
+    }
+    try {
+        const result = await execFileAsync('git', ['worktree', ...gitWtArgs]);
+        if (result.stdout)
+            console.log(result.stdout.trimEnd());
+    }
+    catch (err) {
+        console.error(execErrorMessage(err, 'git worktree add failed'));
+        process.exit(1);
+    }
+    console.log(`Worktree created at ${targetDir}`);
+    const claudeArgs = [];
+    if (hasYolo)
+        claudeArgs.push('--dangerously-skip-permissions');
+    console.log(`Launching claude${hasYolo ? ' (yolo mode)' : ''} in ${targetDir}...`);
+    const child = spawn('claude', claudeArgs, {
+        cwd: targetDir,
+        stdio: 'inherit',
+        env: { ...process.env, CLAUDECODE: undefined },
+    });
+    child.on('exit', (code) => {
+        process.exit(code ?? 0);
+    });
+    // Block until child exits via the handler above
+    await new Promise(() => { });
+}
+if (command === 'install' || command === 'uninstall' || command === 'status' || args.includes('--bg')) {
+    if (command === 'uninstall') {
+        runServiceCommand(() => { service.uninstall(); });
+    }
+    else if (command === 'status') {
+        runServiceCommand(() => {
+            const st = service.status();
+            if (!st.installed) {
+                console.log('Service is not installed.');
+            }
+            else if (st.running) {
+                console.log('Service is installed and running.');
+            }
+            else {
+                console.log('Service is installed but not running.');
+            }
+        });
+    }
+    else {
+        runServiceCommand(() => {
+            service.install({
+                configPath: resolveConfigPath(),
+                port: getArg('--port') ?? String(DEFAULTS.port),
+                host: getArg('--host') ?? DEFAULTS.host,
+            });
+        });
+    }
+}
+const configPath = resolveConfigPath();
+const configDir = path.dirname(configPath);
+// Ensure config directory exists
+if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+}
+// Pass config path and CLI overrides to the server
+process.env['CLAUDE_REMOTE_CONFIG'] = configPath;
+const portArg = getArg('--port');
+if (portArg !== undefined)
+    process.env['CLAUDE_REMOTE_PORT'] = portArg;
+const hostArg = getArg('--host');
+if (hostArg !== undefined)
+    process.env['CLAUDE_REMOTE_HOST'] = hostArg;
+if (args.includes('--debug-log'))
+    process.env['CLAUDE_REMOTE_DEBUG_LOG'] = '1';
+await import('../server/index.js');

package/dist/test/boot-state.test.js

@@ -0,0 +1,133 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+const SERVICES = [
+    'auth',
+    'workspaces',
+    'sessions',
+    'worktrees',
+    'groups',
+];
+function createBootLines() {
+    return SERVICES.map((service) => ({
+        service,
+        status: 'pending',
+    }));
+}
+function derivePhaseAfterFinish(lines) {
+    const fetchLines = lines.filter((l) => l.service !== 'auth');
+    const anyFailed = fetchLines.some((l) => l.status === 'fail');
+    return anyFailed ? 'degraded' : 'ready';
+}
+function reportFetch(lines, service, status, opts) {
+    const idx = lines.findIndex((l) => l.service === service);
+    if (idx === -1)
+        return lines;
+    const updated = [...lines];
+    updated[idx] = {
+        service,
+        status,
+        summary: opts?.summary,
+        durationMs: opts?.durationMs,
+        error: opts?.error,
+    };
+    return updated;
+}
+describe('boot-state', () => {
+    describe('createBootLines', () => {
+        it('creates 5 lines for all services', () => {
+            const lines = createBootLines();
+            assert.strictEqual(lines.length, 5);
+            assert.deepStrictEqual(lines.map((l) => l.service), ['auth', 'workspaces', 'sessions', 'worktrees', 'groups']);
+        });
+        it('all lines start as pending', () => {
+            const lines = createBootLines();
+            for (const line of lines) {
+                assert.strictEqual(line.status, 'pending');
+            }
+        });
+    });
+    describe('reportFetch', () => {
+        it('updates a known service to loading', () => {
+            let lines = createBootLines();
+            lines = reportFetch(lines, 'workspaces', 'loading');
+            const ws = lines.find((l) => l.service === 'workspaces');
+            assert.strictEqual(ws.status, 'loading');
+        });
+        it('updates a service to ok with summary and duration', () => {
+            let lines = createBootLines();
+            lines = reportFetch(lines, 'sessions', 'ok', {
+                summary: '2 active',
+                durationMs: 42,
+            });
+            const sess = lines.find((l) => l.service === 'sessions');
+            assert.strictEqual(sess.status, 'ok');
+            assert.strictEqual(sess.summary, '2 active');
+            assert.strictEqual(sess.durationMs, 42);
+        });
+        it('updates a service to fail with error', () => {
+            let lines = createBootLines();
+            lines = reportFetch(lines, 'worktrees', 'fail', {
+                error: 'timeout',
+                durationMs: 5000,
+            });
+            const wt = lines.find((l) => l.service === 'worktrees');
+            assert.strictEqual(wt.status, 'fail');
+            assert.strictEqual(wt.error, 'timeout');
+            assert.strictEqual(wt.durationMs, 5000);
+        });
+        it('ignores unknown service', () => {
+            let lines = createBootLines();
+            const original = [...lines];
+            lines = reportFetch(lines, 'unknown-service', 'ok');
+            assert.deepStrictEqual(lines, original);
+        });
+        it('does not affect other lines', () => {
+            let lines = createBootLines();
+            lines = reportFetch(lines, 'auth', 'ok', { durationMs: 10 });
+            // All other lines should still be pending
+            for (const line of lines) {
+                if (line.service !== 'auth') {
+                    assert.strictEqual(line.status, 'pending', `${line.service} should still be pending`);
+                }
+            }
+        });
+    });
+    describe('derivePhaseAfterFinish', () => {
+        it('returns ready when all non-auth lines are ok', () => {
+            let lines = createBootLines();
+            lines = reportFetch(lines, 'auth', 'ok');
+            lines = reportFetch(lines, 'workspaces', 'ok', { summary: '3 repos' });
+            lines = reportFetch(lines, 'sessions', 'ok', { summary: '2 active' });
+            lines = reportFetch(lines, 'worktrees', 'ok', { summary: '1 tree' });
+            lines = reportFetch(lines, 'groups', 'ok', { summary: '0 groups' });
+            assert.strictEqual(derivePhaseAfterFinish(lines), 'ready');
+        });
+        it('returns degraded when one fetch fails', () => {
+            let lines = createBootLines();
+            lines = reportFetch(lines, 'auth', 'ok');
+            lines = reportFetch(lines, 'workspaces', 'ok', { summary: '3 repos' });
+            lines = reportFetch(lines, 'sessions', 'fail', { error: 'timeout' });
+            lines = reportFetch(lines, 'worktrees', 'ok', { summary: '1 tree' });
+            lines = reportFetch(lines, 'groups', 'ok', { summary: '0 groups' });
+            assert.strictEqual(derivePhaseAfterFinish(lines), 'degraded');
+        });
+        it('returns degraded when all fetches fail', () => {
+            let lines = createBootLines();
+            lines = reportFetch(lines, 'auth', 'ok');
+            lines = reportFetch(lines, 'workspaces', 'fail', { error: 'network' });
+            lines = reportFetch(lines, 'sessions', 'fail', { error: 'network' });
+            lines = reportFetch(lines, 'worktrees', 'fail', { error: 'network' });
+            lines = reportFetch(lines, 'groups', 'fail', { error: 'network' });
+            assert.strictEqual(derivePhaseAfterFinish(lines), 'degraded');
+        });
+        it('ignores auth status when deriving phase', () => {
+            let lines = createBootLines();
+            lines = reportFetch(lines, 'auth', 'fail'); // auth failed but non-auth are ok
+            lines = reportFetch(lines, 'workspaces', 'ok', { summary: '3 repos' });
+            lines = reportFetch(lines, 'sessions', 'ok', { summary: '0 active' });
+            lines = reportFetch(lines, 'worktrees', 'ok', { summary: '0 trees' });
+            lines = reportFetch(lines, 'groups', 'ok', { summary: '0 groups' });
+            assert.strictEqual(derivePhaseAfterFinish(lines), 'ready');
+        });
+    });
+});

package/dist/test/branch-lifecycle.test.js

@@ -0,0 +1,75 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { isPrMerged, computeBranchLifecycleState } from '../server/git.js';
+describe('isPrMerged', () => {
+    it('returns true for MERGED state', () => {
+        const pr = { state: 'MERGED' };
+        assert.equal(isPrMerged(pr), true);
+    });
+    it('returns false for OPEN state', () => {
+        const pr = { state: 'OPEN' };
+        assert.equal(isPrMerged(pr), false);
+    });
+    it('returns false for CLOSED (not merged) state', () => {
+        const pr = { state: 'CLOSED' };
+        assert.equal(isPrMerged(pr), false);
+    });
+});
+describe('computeBranchLifecycleState', () => {
+    it('returns merged when PR is merged', () => {
+        const result = computeBranchLifecycleState({
+            pr: { state: 'MERGED', number: 42, title: 'Fix auth' },
+            isBranchStale: false,
+            hasActiveSessions: true,
+            isMainBranch: false,
+        });
+        assert.equal(result.state, 'merged');
+        assert.equal(result.prNumber, 42);
+        assert.equal(result.prTitle, 'Fix auth');
+    });
+    it('returns active when branch has active sessions', () => {
+        const result = computeBranchLifecycleState({
+            pr: null,
+            isBranchStale: true,
+            hasActiveSessions: true,
+            isMainBranch: false,
+        });
+        assert.equal(result.state, 'active');
+    });
+    it('returns stale when no sessions and branch is stale', () => {
+        const result = computeBranchLifecycleState({
+            pr: null,
+            isBranchStale: true,
+            hasActiveSessions: false,
+            isMainBranch: false,
+        });
+        assert.equal(result.state, 'stale');
+    });
+    it('returns active when branch is not stale and no sessions', () => {
+        const result = computeBranchLifecycleState({
+            pr: null,
+            isBranchStale: false,
+            hasActiveSessions: false,
+            isMainBranch: false,
+        });
+        assert.equal(result.state, 'active');
+    });
+    it('never returns merged for main branch even if PR is merged', () => {
+        const result = computeBranchLifecycleState({
+            pr: { state: 'MERGED', number: 1, title: 'Main PR' },
+            isBranchStale: false,
+            hasActiveSessions: false,
+            isMainBranch: true,
+        });
+        assert.equal(result.state, 'active');
+    });
+    it('main branch can be stale but never merged', () => {
+        const result = computeBranchLifecycleState({
+            pr: null,
+            isBranchStale: true,
+            hasActiveSessions: false,
+            isMainBranch: true,
+        });
+        assert.equal(result.state, 'stale');
+    });
+});