specdacular 0.12.0 → 0.13.1

package/runner/main/server/websocket.js

@@ -1,24 +0,0 @@
-// runner/main/server/websocket.js
-import { WebSocketServer } from 'ws';
-
-export class WsBroadcaster {
-  constructor(server) {
-    this.wss = new WebSocketServer({ server });
-    this.wss.on('connection', (ws) => {
-      ws.send(JSON.stringify({ type: 'connected', timestamp: new Date().toISOString() }));
-    });
-  }
-
-  broadcast(event) {
-    const data = JSON.stringify(event);
-    for (const client of this.wss.clients) {
-      if (client.readyState === 1) {
-        client.send(data);
-      }
-    }
-  }
-
-  close() {
-    this.wss.close();
-  }
-}

package/runner/main/state/manager.js

@@ -1,83 +0,0 @@
-import { writeFileSync, existsSync, readFileSync } from 'fs';
-import { EventEmitter } from 'events';
-
-export class StateManager extends EventEmitter {
-  constructor(statusPath) {
-    super();
-    this.statusPath = statusPath;
-    this.state = existsSync(statusPath)
-      ? JSON.parse(readFileSync(statusPath, 'utf-8'))
-      : { started_at: new Date().toISOString(), tasks: {} };
-  }
-
-  getState() {
-    return this.state;
-  }
-
-  registerTask(taskId, { name, pipeline }) {
-    this.state.tasks[taskId] = {
-      name,
-      status: 'queued',
-      current_stage: null,
-      pipeline,
-      pr_url: null,
-      stages: [],
-    };
-    this._emit('task_registered', { taskId, name });
-  }
-
-  updateTaskStatus(taskId, status) {
-    this.state.tasks[taskId].status = status;
-    this._emit('task_status_changed', { taskId, status });
-  }
-
-  startStage(taskId, { stage, agent }) {
-    const task = this.state.tasks[taskId];
-    task.current_stage = stage;
-    task.stages.push({
-      stage,
-      agent,
-      status: 'running',
-      started_at: new Date().toISOString(),
-      duration: null,
-      summary: null,
-      live_progress: null,
-    });
-    this._emit('stage_started', { taskId, stage, agent });
-  }
-
-  updateLiveProgress(taskId, progress) {
-    const task = this.state.tasks[taskId];
-    const currentStage = task.stages[task.stages.length - 1];
-    if (currentStage) {
-      currentStage.live_progress = progress;
-      currentStage.last_output_at = new Date().toISOString();
-    }
-    this._emit('live_progress', { taskId, progress });
-  }
-
-  completeStage(taskId, status, summary) {
-    const task = this.state.tasks[taskId];
-    const currentStage = task.stages[task.stages.length - 1];
-    if (currentStage) {
-      currentStage.status = status;
-      currentStage.summary = summary;
-      const started = new Date(currentStage.started_at);
-      currentStage.duration = Math.round((Date.now() - started.getTime()) / 1000);
-    }
-    this._emit('stage_completed', { taskId, stage: currentStage?.stage, status, summary });
-  }
-
-  setPrUrl(taskId, prUrl) {
-    this.state.tasks[taskId].pr_url = prUrl;
-    this._emit('pr_created', { taskId, prUrl });
-  }
-
-  persist() {
-    writeFileSync(this.statusPath, JSON.stringify(this.state, null, 2));
-  }
-
-  _emit(type, data) {
-    this.emit('change', { type, ...data });
-  }
-}

package/runner/main/template-manager.js

@@ -1,41 +0,0 @@
-import { readdirSync, readFileSync, existsSync } from 'fs';
-import { join, basename } from 'path';
-
-export class TemplateManager {
-  constructor(paths) {
-    this.paths = paths;
-  }
-
-  getAgents(projectId) {
-    const global = this._loadDir(this.paths.agentTemplatesDir);
-    if (!projectId) return global;
-
-    const projectAgentsDir = join(this.paths.projectsDir, projectId, 'agents');
-    if (!existsSync(projectAgentsDir)) return global;
-
-    const overrides = this._loadDir(projectAgentsDir);
-    return { ...global, ...overrides };
-  }
-
-  getPipelines(projectId) {
-    const global = this._loadDir(this.paths.pipelineTemplatesDir);
-    if (!projectId) return global;
-
-    const projectPipelinesDir = join(this.paths.projectsDir, projectId, 'pipelines');
-    if (!existsSync(projectPipelinesDir)) return global;
-
-    const overrides = this._loadDir(projectPipelinesDir);
-    return { ...global, ...overrides };
-  }
-
-  _loadDir(dir) {
-    if (!existsSync(dir)) return {};
-    const result = {};
-    for (const file of readdirSync(dir)) {
-      if (!file.endsWith('.json')) continue;
-      const name = basename(file, '.json');
-      result[name] = JSON.parse(readFileSync(join(dir, file), 'utf-8'));
-    }
-    return result;
-  }
-}

package/runner/main/test/agent-parser.test.js

@@ -1,44 +0,0 @@
-import { describe, it } from 'node:test';
-import { strict as a } from 'node:assert';
-import { StreamParser } from '../agent/parser.js';
-
-describe('StreamParser', () => {
-  it('parses specd-status blocks', () => {
-    const parser = new StreamParser();
-    const statuses = [];
-    parser.on('status', (s) => statuses.push(s));
-
-    parser.feed('some output');
-    parser.feed('```specd-status');
-    parser.feed('{"progress":"Working","percent":50}');
-    parser.feed('```');
-
-    a.equal(statuses.length, 1);
-    a.equal(statuses[0].progress, 'Working');
-    a.equal(statuses[0].percent, 50);
-  });
-
-  it('parses specd-result blocks', () => {
-    const parser = new StreamParser();
-    const results = [];
-    parser.on('result', (r) => results.push(r));
-
-    parser.feed('```specd-result');
-    parser.feed('{"status":"success","summary":"Done"}');
-    parser.feed('```');
-
-    a.equal(results.length, 1);
-    a.equal(results[0].status, 'success');
-  });
-
-  it('emits output for non-block lines', () => {
-    const parser = new StreamParser();
-    const lines = [];
-    parser.on('output', (l) => lines.push(l));
-
-    parser.feed('hello world');
-
-    a.equal(lines.length, 1);
-    a.equal(lines[0], 'hello world');
-  });
-});

package/runner/main/test/bootstrap.test.js

@@ -1,58 +0,0 @@
-import { describe, it, before, after } from 'node:test';
-import { strict as a } from 'node:assert';
-import { mkdtempSync, rmSync, existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { bootstrap } from '../bootstrap.js';
-import { Paths } from '../paths.js';
-
-describe('bootstrap', () => {
-  let tempDir;
-  let paths;
-
-  before(() => {
-    tempDir = mkdtempSync(join(tmpdir(), 'specd-test-'));
-    paths = new Paths(tempDir);
-  });
-
-  after(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  it('creates all required directories and default files', async () => {
-    await bootstrap(paths);
-
-    a.ok(existsSync(paths.templatesDir));
-    a.ok(existsSync(paths.agentTemplatesDir));
-    a.ok(existsSync(paths.pipelineTemplatesDir));
-    a.ok(existsSync(paths.projectsDir));
-
-    a.ok(existsSync(paths.db));
-    const db = JSON.parse(readFileSync(paths.db, 'utf-8'));
-    a.deepEqual(db, { projects: [] });
-
-    a.ok(existsSync(paths.config));
-    const config = JSON.parse(readFileSync(paths.config, 'utf-8'));
-    a.equal(config.server.port, 3700);
-
-    // Default agent templates exist
-    a.ok(existsSync(join(paths.agentTemplatesDir, 'claude-planner.json')));
-    a.ok(existsSync(join(paths.agentTemplatesDir, 'claude-implementer.json')));
-    a.ok(existsSync(join(paths.agentTemplatesDir, 'claude-reviewer.json')));
-
-    // Default pipeline template exists
-    a.ok(existsSync(join(paths.pipelineTemplatesDir, 'default.json')));
-  });
-
-  it('does not overwrite existing files on second run', async () => {
-    const config = JSON.parse(readFileSync(paths.config, 'utf-8'));
-    config.server.port = 9999;
-    const { writeFileSync } = await import('fs');
-    writeFileSync(paths.config, JSON.stringify(config));
-
-    await bootstrap(paths);
-
-    const reloaded = JSON.parse(readFileSync(paths.config, 'utf-8'));
-    a.equal(reloaded.server.port, 9999);
-  });
-});

package/runner/main/test/db.test.js

@@ -1,72 +0,0 @@
-import { describe, it, before, after, beforeEach } from 'node:test';
-import { strict as a } from 'node:assert';
-import { mkdtempSync, rmSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { ProjectDB } from '../db.js';
-
-describe('ProjectDB', () => {
-  let tempDir;
-  let dbPath;
-  let db;
-
-  before(() => {
-    tempDir = mkdtempSync(join(tmpdir(), 'specd-db-test-'));
-    dbPath = join(tempDir, 'db.json');
-  });
-
-  beforeEach(() => {
-    writeFileSync(dbPath, JSON.stringify({ projects: [] }));
-    db = new ProjectDB(dbPath);
-  });
-
-  after(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  it('registers a project', () => {
-    const project = db.register('my-project', '/Users/victor/work/my-project');
-    a.equal(project.name, 'my-project');
-    a.equal(project.path, '/Users/victor/work/my-project');
-    a.equal(project.active, true);
-    a.ok(project.id);
-    a.ok(project.registeredAt);
-  });
-
-  it('lists projects', () => {
-    db.register('proj-a', '/a');
-    db.register('proj-b', '/b');
-    const list = db.list();
-    a.equal(list.length, 2);
-  });
-
-  it('gets a project by id', () => {
-    const project = db.register('my-project', '/path');
-    const found = db.get(project.id);
-    a.equal(found.name, 'my-project');
-  });
-
-  it('finds a project by path', () => {
-    db.register('my-project', '/Users/victor/work/my-project');
-    const found = db.findByPath('/Users/victor/work/my-project');
-    a.equal(found.name, 'my-project');
-  });
-
-  it('finds a project by subdirectory path', () => {
-    db.register('my-project', '/Users/victor/work');
-    const found = db.findByPath('/Users/victor/work/repo-a');
-    a.equal(found.name, 'my-project');
-  });
-
-  it('unregisters a project', () => {
-    const project = db.register('my-project', '/path');
-    db.unregister(project.id);
-    a.equal(db.list().length, 0);
-  });
-
-  it('persists to disk', () => {
-    db.register('my-project', '/path');
-    const db2 = new ProjectDB(dbPath);
-    a.equal(db2.list().length, 1);
-  });
-});

package/runner/main/test/paths.test.js

@@ -1,29 +0,0 @@
-import { describe, it } from 'node:test';
-import { strict as a } from 'node:assert';
-import { Paths } from '../paths.js';
-
-describe('Paths', () => {
-  it('returns app data dir based on platform', () => {
-    const paths = new Paths('/tmp/test-specd');
-    a.equal(paths.root, '/tmp/test-specd');
-    a.equal(paths.db, '/tmp/test-specd/db.json');
-    a.equal(paths.config, '/tmp/test-specd/config.json');
-    a.equal(paths.templatesDir, '/tmp/test-specd/templates');
-    a.equal(paths.agentTemplatesDir, '/tmp/test-specd/templates/agents');
-    a.equal(paths.pipelineTemplatesDir, '/tmp/test-specd/templates/pipelines');
-    a.equal(paths.projectsDir, '/tmp/test-specd/projects');
-    a.equal(paths.electronDir, '/tmp/test-specd/electron');
-  });
-
-  it('returns project-specific paths', () => {
-    const paths = new Paths('/tmp/test-specd');
-    const pp = paths.forProject('abc123');
-    a.equal(pp.dir, '/tmp/test-specd/projects/abc123');
-    a.equal(pp.projectJson, '/tmp/test-specd/projects/abc123/project.json');
-    a.equal(pp.statusJson, '/tmp/test-specd/projects/abc123/status.json');
-    a.equal(pp.tasksDir, '/tmp/test-specd/projects/abc123/tasks');
-    a.equal(pp.logsDir, '/tmp/test-specd/projects/abc123/logs');
-    a.equal(pp.agentsDir, '/tmp/test-specd/projects/abc123/agents');
-    a.equal(pp.pipelinesDir, '/tmp/test-specd/projects/abc123/pipelines');
-  });
-});

package/runner/main/test/state-manager.test.js

@@ -1,72 +0,0 @@
-import { describe, it, before, after, beforeEach } from 'node:test';
-import { strict as a } from 'node:assert';
-import { mkdtempSync, rmSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { StateManager } from '../state/manager.js';
-
-describe('StateManager', () => {
-  let tempDir;
-  let statusPath;
-  let sm;
-
-  before(() => {
-    tempDir = mkdtempSync(join(tmpdir(), 'specd-state-test-'));
-  });
-
-  beforeEach(() => {
-    statusPath = join(tempDir, `status-${Date.now()}.json`);
-    sm = new StateManager(statusPath);
-  });
-
-  after(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  it('registers a task', () => {
-    sm.registerTask('task-001', { name: 'Add dark mode', pipeline: 'default' });
-    const state = sm.getState();
-    a.equal(state.tasks['task-001'].name, 'Add dark mode');
-    a.equal(state.tasks['task-001'].status, 'queued');
-  });
-
-  it('updates task status', () => {
-    sm.registerTask('task-001', { name: 'Test', pipeline: 'default' });
-    sm.updateTaskStatus('task-001', 'in_progress');
-    a.equal(sm.getState().tasks['task-001'].status, 'in_progress');
-  });
-
-  it('tracks stages', () => {
-    sm.registerTask('task-001', { name: 'Test', pipeline: 'default' });
-    sm.startStage('task-001', { stage: 'plan', agent: 'claude-planner' });
-    const task = sm.getState().tasks['task-001'];
-    a.equal(task.current_stage, 'plan');
-    a.equal(task.stages.length, 1);
-    a.equal(task.stages[0].status, 'running');
-  });
-
-  it('completes stages with duration', () => {
-    sm.registerTask('task-001', { name: 'Test', pipeline: 'default' });
-    sm.startStage('task-001', { stage: 'plan', agent: 'claude-planner' });
-    sm.completeStage('task-001', 'success', 'Planned it');
-    const stage = sm.getState().tasks['task-001'].stages[0];
-    a.equal(stage.status, 'success');
-    a.equal(stage.summary, 'Planned it');
-    a.ok(stage.duration >= 0);
-  });
-
-  it('persists to disk', () => {
-    sm.registerTask('task-001', { name: 'Test', pipeline: 'default' });
-    sm.persist();
-    const data = JSON.parse(readFileSync(statusPath, 'utf-8'));
-    a.ok(data.tasks['task-001']);
-  });
-
-  it('emits change events', () => {
-    const events = [];
-    sm.on('change', (e) => events.push(e));
-    sm.registerTask('task-001', { name: 'Test', pipeline: 'default' });
-    a.equal(events.length, 1);
-    a.equal(events[0].type, 'task_registered');
-  });
-});

package/runner/main/test/template-manager.test.js

@@ -1,66 +0,0 @@
-import { describe, it, before, after } from 'node:test';
-import { strict as a } from 'node:assert';
-import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { TemplateManager } from '../template-manager.js';
-import { Paths } from '../paths.js';
-
-describe('TemplateManager', () => {
-  let tempDir;
-  let paths;
-  let tm;
-
-  before(() => {
-    tempDir = mkdtempSync(join(tmpdir(), 'specd-tm-test-'));
-    paths = new Paths(tempDir);
-
-    // Create global templates
-    mkdirSync(paths.agentTemplatesDir, { recursive: true });
-    mkdirSync(paths.pipelineTemplatesDir, { recursive: true });
-
-    writeFileSync(
-      join(paths.agentTemplatesDir, 'claude-planner.json'),
-      JSON.stringify({ cmd: 'claude -p', system_prompt: 'global planner' })
-    );
-    writeFileSync(
-      join(paths.pipelineTemplatesDir, 'default.json'),
-      JSON.stringify({ name: 'default', stages: [{ stage: 'plan', agent: 'claude-planner' }] })
-    );
-
-    // Create per-project override
-    const projectAgentsDir = join(paths.projectsDir, 'proj1', 'agents');
-    mkdirSync(projectAgentsDir, { recursive: true });
-    writeFileSync(
-      join(projectAgentsDir, 'claude-planner.json'),
-      JSON.stringify({ cmd: 'claude -p --model opus', system_prompt: 'custom planner' })
-    );
-
-    tm = new TemplateManager(paths);
-  });
-
-  after(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  it('loads global agents', () => {
-    const agents = tm.getAgents();
-    a.equal(agents['claude-planner'].system_prompt, 'global planner');
-  });
-
-  it('loads global pipelines', () => {
-    const pipelines = tm.getPipelines();
-    a.equal(pipelines['default'].stages.length, 1);
-  });
-
-  it('returns per-project agent override when present', () => {
-    const agents = tm.getAgents('proj1');
-    a.equal(agents['claude-planner'].system_prompt, 'custom planner');
-    a.equal(agents['claude-planner'].cmd, 'claude -p --model opus');
-  });
-
-  it('falls back to global when no per-project override', () => {
-    const agents = tm.getAgents('proj-no-overrides');
-    a.equal(agents['claude-planner'].system_prompt, 'global planner');
-  });
-});

package/runner/main/worktree/manager.js

@@ -1,95 +0,0 @@
-// runner/main/worktree/manager.js
-import { execSync, execFileSync } from 'child_process';
-import { existsSync, mkdirSync, rmSync } from 'fs';
-import { join, basename } from 'path';
-import { tmpdir } from 'os';
-
-export class WorktreeManager {
-  constructor(repoDir) {
-    this.repoDir = repoDir;
-    this.worktreesDir = join(tmpdir(), 'specd-worktrees', basename(repoDir));
-    this.active = new Map();
-  }
-
-  create(taskId) {
-    const branch = `specd/${taskId}`;
-    const worktreePath = join(this.worktreesDir, taskId);
-
-    mkdirSync(this.worktreesDir, { recursive: true });
-
-    // Create branch from current HEAD
-    try {
-      execSync(`git branch ${branch}`, { cwd: this.repoDir, stdio: 'pipe' });
-    } catch {
-      // Branch may already exist
-    }
-
-    execSync(`git worktree add "${worktreePath}" ${branch}`, {
-      cwd: this.repoDir,
-      stdio: 'pipe',
-    });
-
-    this.active.set(taskId, worktreePath);
-    return worktreePath;
-  }
-
-  remove(taskId, deleteBranch = false) {
-    const worktreePath = this.active.get(taskId);
-    if (!worktreePath) return;
-
-    execSync(`git worktree remove "${worktreePath}" --force`, {
-      cwd: this.repoDir,
-      stdio: 'pipe',
-    });
-
-    if (deleteBranch) {
-      try {
-        execSync(`git branch -D specd/${taskId}`, { cwd: this.repoDir, stdio: 'pipe' });
-      } catch {
-        // Branch may not exist
-      }
-    }
-
-    this.active.delete(taskId);
-  }
-
-  hasChanges(taskId) {
-    const worktreePath = this.active.get(taskId);
-    if (!worktreePath) return false;
-
-    try {
-      const base = execSync('git merge-base HEAD main', { cwd: worktreePath, encoding: 'utf-8' }).trim();
-      const head = execSync('git rev-parse HEAD', { cwd: worktreePath, encoding: 'utf-8' }).trim();
-      return base !== head;
-    } catch {
-      return false;
-    }
-  }
-
-  createPR(taskId, taskName, summary) {
-    const worktreePath = this.active.get(taskId);
-    if (!worktreePath) return null;
-
-    const branch = `specd/${taskId}`;
-
-    try {
-      execFileSync('git', ['push', '-u', 'origin', branch], { cwd: worktreePath, stdio: 'pipe' });
-      const prUrl = execFileSync(
-        'gh', ['pr', 'create', '--title', taskName, '--body', summary, '--head', branch],
-        { cwd: worktreePath, encoding: 'utf-8' }
-      ).trim();
-      return prUrl;
-    } catch (err) {
-      console.error(`PR creation failed for ${taskId}:`, err.message);
-      return null;
-    }
-  }
-
-  getPath(taskId) {
-    return this.active.get(taskId) || null;
-  }
-
-  listActive() {
-    return [...this.active.keys()];
-  }
-}

package/runner/package.json

@@ -1,20 +0,0 @@
-{
-  "name": "@specd/runner",
-  "version": "0.2.0",
-  "description": "Specd Runner — Electron desktop app for autonomous agent orchestration",
-  "type": "module",
-  "main": "main/index.js",
-  "scripts": {
-    "start": "electron .",
-    "dev": "NODE_ENV=development electron .",
-    "build:renderer": "cd renderer && npm run build"
-  },
-  "dependencies": {
-    "electron": "^34.0.0",
-    "express": "^4.21.0",
-    "ws": "^8.18.0"
-  },
-  "engines": {
-    "node": ">=18"
-  }
-}

package/runner/preload.js

@@ -1,19 +0,0 @@
-const { contextBridge, ipcRenderer } = require('electron');
-
-const ALLOWED_CHANNELS = new Set([
-  'get-projects', 'get-project-status', 'get-tasks',
-  'get-task', 'create-task', 'retry-task', 'get-task-logs', 'get-config',
-]);
-
-contextBridge.exposeInMainWorld('specd', {
-  invoke: (channel, ...args) => {
-    if (!ALLOWED_CHANNELS.has(channel)) throw new Error(`Blocked IPC channel: ${channel}`);
-    return ipcRenderer.invoke(channel, ...args);
-  },
-  on: (channel, callback) => {
-    if (!ALLOWED_CHANNELS.has(channel)) throw new Error(`Blocked IPC channel: ${channel}`);
-    const subscription = (_event, ...args) => callback(...args);
-    ipcRenderer.on(channel, subscription);
-    return () => ipcRenderer.removeListener(channel, subscription);
-  },
-});