specdacular 0.12.0 → 0.13.1

package/runner/main/index.js

@@ -1,103 +0,0 @@
-// runner/main/index.js
-import { app, BrowserWindow } from 'electron';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-import { readFileSync, existsSync, writeFileSync, mkdirSync } from 'fs';
-import { Paths } from './paths.js';
-import { bootstrap } from './bootstrap.js';
-import { ProjectDB } from './db.js';
-import { Orchestrator } from './orchestrator.js';
-import { createServer } from './server/index.js';
-import { setupIpc } from './ipc.js';
-
-let mainWindow;
-const paths = new Paths();
-const orchestrators = new Map();
-let db;
-let config;
-let server;
-
-function getContext() {
-  return { db, config, paths, orchestrators };
-}
-
-async function initBackend() {
-  await bootstrap(paths);
-
-  db = new ProjectDB(paths.db);
-  config = JSON.parse(readFileSync(paths.config, 'utf-8'));
-
-  // Initialize orchestrators for active projects
-  for (const project of db.list().filter(p => p.active)) {
-    // Ensure project.json exists (may not if registered via CLI only)
-    const projectPaths = paths.forProject(project.id);
-    mkdirSync(projectPaths.dir, { recursive: true });
-    if (!existsSync(projectPaths.projectJson)) {
-      writeFileSync(projectPaths.projectJson, JSON.stringify({
-        name: project.name,
-        path: project.path,
-        registeredAt: project.registeredAt,
-      }, null, 2));
-    }
-
-    const orch = new Orchestrator({ projectId: project.id, paths, config });
-    orch.init();
-    orchestrators.set(project.id, orch);
-  }
-
-  // Start API server
-  server = createServer(getContext);
-  const port = config.server?.port || 3700;
-  await server.start(port);
-
-  // Wire orchestrators to WebSocket
-  for (const orch of orchestrators.values()) {
-    server.wireOrchestrator(orch);
-  }
-
-  // Start orchestrator loops
-  for (const orch of orchestrators.values()) {
-    orch.startLoop().catch(err => console.error('Loop error:', err));
-  }
-}
-
-function createWindow() {
-  mainWindow = new BrowserWindow({
-    width: 1200,
-    height: 800,
-    webPreferences: {
-      preload: join(__dirname, '..', 'preload.js'),
-      contextIsolation: true,
-      nodeIntegration: false,
-    },
-  });
-
-  if (process.env.NODE_ENV === 'development') {
-    mainWindow.loadURL('http://localhost:5173');
-  } else {
-    mainWindow.loadFile(join(__dirname, '..', 'renderer', 'dist', 'index.html'));
-  }
-}
-
-app.whenReady().then(async () => {
-  setupIpc(getContext);
-  await initBackend();
-  createWindow();
-});
-
-app.on('window-all-closed', () => {
-  if (process.platform !== 'darwin') app.quit();
-});
-
-app.on('activate', () => {
-  if (BrowserWindow.getAllWindows().length === 0) createWindow();
-});
-
-app.on('before-quit', () => {
-  for (const orch of orchestrators.values()) {
-    orch.stop();
-  }
-  if (server) server.stop();
-});

package/runner/main/ipc.js

@@ -1,72 +0,0 @@
-// runner/main/ipc.js
-import { ipcMain } from 'electron';
-import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
-
-export function setupIpc(getContext) {
-  ipcMain.handle('get-projects', () => {
-    const { db, orchestrators } = getContext();
-    return db.list().map(p => {
-      const orch = orchestrators.get(p.id);
-      const tasks = orch ? orch.getTasks() : [];
-      return {
-        ...p,
-        taskCounts: {
-          total: tasks.length,
-          ready: tasks.filter(t => t.status === 'ready').length,
-          running: tasks.filter(t => t.status === 'in_progress').length,
-          done: tasks.filter(t => t.status === 'done').length,
-          failed: tasks.filter(t => t.status === 'failed').length,
-        },
-      };
-    });
-  });
-
-  ipcMain.handle('get-project-status', (event, projectId) => {
-    const { orchestrators } = getContext();
-    const orch = orchestrators.get(projectId);
-    if (!orch) return null;
-    return orch.stateManager.getState();
-  });
-
-  ipcMain.handle('get-tasks', (event, projectId) => {
-    const { orchestrators } = getContext();
-    const orch = orchestrators.get(projectId);
-    if (!orch) return [];
-    return orch.getTasks();
-  });
-
-  ipcMain.handle('get-task', (event, projectId, taskId) => {
-    const { orchestrators } = getContext();
-    const orch = orchestrators.get(projectId);
-    if (!orch) return null;
-    return orch.getTask(taskId);
-  });
-
-  ipcMain.handle('create-task', (event, projectId, taskData) => {
-    const { orchestrators } = getContext();
-    const orch = orchestrators.get(projectId);
-    if (!orch) return null;
-    return orch.createTask(taskData);
-  });
-
-  ipcMain.handle('retry-task', (event, projectId, taskId) => {
-    const { orchestrators } = getContext();
-    const orch = orchestrators.get(projectId);
-    if (!orch) return null;
-    return orch.updateTask(taskId, { status: 'ready' });
-  });
-
-  ipcMain.handle('get-task-logs', (event, projectId, taskId) => {
-    const { paths } = getContext();
-    const logPath = join(paths.forProject(projectId).logsDir, `${taskId}.log`);
-    if (!existsSync(logPath)) return { lines: [] };
-    const content = readFileSync(logPath, 'utf-8');
-    return { lines: content.split('\n').slice(-200) };
-  });
-
-  ipcMain.handle('get-config', () => {
-    const { config } = getContext();
-    return config;
-  });
-}

package/runner/main/notifications/telegram.js

@@ -1,45 +0,0 @@
-// runner/main/notifications/telegram.js
-import { request } from 'https';
-
-export class TelegramNotifier {
-  constructor({ bot_token, chat_id, notify_on }) {
-    this.botToken = bot_token;
-    this.chatId = chat_id;
-    this.notifyOn = new Set(notify_on || ['task_complete', 'task_failed']);
-  }
-
-  async onTaskComplete(taskId, taskName, summary) {
-    if (!this.notifyOn.has('task_complete')) return;
-    await this._send(`✅ *Task Complete*\n*${taskName}* (${taskId})\n${summary}`);
-  }
-
-  async onTaskFailed(taskId, taskName, stage, error) {
-    if (!this.notifyOn.has('task_failed')) return;
-    await this._send(`❌ *Task Failed*\n*${taskName}* (${taskId})\nStage: ${stage}\nError: ${error}`);
-  }
-
-  async onStuck(taskId, taskName, stage) {
-    if (!this.notifyOn.has('task_stuck')) return;
-    await this._send(`⚠️ *Agent Stuck*\n*${taskName}* (${taskId})\nStage: ${stage}`);
-  }
-
-  async onNeedsInput(taskId, taskName, stage, question) {
-    if (!this.notifyOn.has('needs_input')) return;
-    await this._send(`❓ *Input Needed*\n*${taskName}* (${taskId})\nStage: ${stage}\n${question}`);
-  }
-
-  _send(text) {
-    return new Promise((resolve) => {
-      const data = JSON.stringify({ chat_id: this.chatId, text, parse_mode: 'Markdown' });
-      const req = request({
-        hostname: 'api.telegram.org',
-        path: `/bot${this.botToken}/sendMessage`,
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) },
-      }, resolve);
-      req.on('error', (err) => { console.error('Telegram error:', err.message); resolve(); });
-      req.write(data);
-      req.end();
-    });
-  }
-}

package/runner/main/orchestrator.js

@@ -1,193 +0,0 @@
-// runner/main/orchestrator.js
-import { readFileSync, readdirSync, writeFileSync, existsSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { EventEmitter } from 'events';
-import { StateManager } from './state/manager.js';
-import { TemplateManager } from './template-manager.js';
-import { AgentRunner } from './agent/runner.js';
-import { StageSequencer } from './pipeline/sequencer.js';
-import { resolvePipeline } from './pipeline/resolver.js';
-import { resolveTemplate, buildTemplateContext } from './agent/template.js';
-import { WorktreeManager } from './worktree/manager.js';
-
-export class Orchestrator extends EventEmitter {
-  constructor({ projectId, paths, config }) {
-    super();
-    this.projectId = projectId;
-    this.paths = paths;
-    this.config = config;
-    this.projectPaths = paths.forProject(projectId);
-    this.stateManager = new StateManager(this.projectPaths.statusJson);
-    this.templateManager = new TemplateManager(paths);
-    this.running = false;
-    this.runningTasks = new Set();
-    this.worktreeManager = null;
-  }
-
-  init() {
-    // Ensure project dirs exist
-    mkdirSync(this.projectPaths.tasksDir, { recursive: true });
-    mkdirSync(this.projectPaths.logsDir, { recursive: true });
-
-    // Load project config
-    const projectJson = JSON.parse(readFileSync(this.projectPaths.projectJson, 'utf-8'));
-    this.projectPath = projectJson.path;
-
-    // Init worktree manager if parallel
-    const maxParallel = this.config.defaults?.max_parallel || 1;
-    if (maxParallel > 1 && existsSync(join(this.projectPath, '.git'))) {
-      this.worktreeManager = new WorktreeManager(this.projectPath);
-    }
-
-    // Forward state events
-    this.stateManager.on('change', (event) => {
-      this.emit('change', { ...event, project: this.projectId });
-    });
-  }
-
-  getTasks() {
-    const tasksDir = this.projectPaths.tasksDir;
-    if (!existsSync(tasksDir)) return [];
-    return readdirSync(tasksDir)
-      .filter(f => f.endsWith('.json'))
-      .map(f => JSON.parse(readFileSync(join(tasksDir, f), 'utf-8')));
-  }
-
-  getTask(taskId) {
-    const taskPath = join(this.projectPaths.tasksDir, `${taskId}.json`);
-    if (!existsSync(taskPath)) return null;
-    return JSON.parse(readFileSync(taskPath, 'utf-8'));
-  }
-
-  createTask(task) {
-    mkdirSync(this.projectPaths.tasksDir, { recursive: true });
-    const taskPath = join(this.projectPaths.tasksDir, `${task.id}.json`);
-    writeFileSync(taskPath, JSON.stringify(task, null, 2));
-    return task;
-  }
-
-  updateTask(taskId, updates) {
-    const task = this.getTask(taskId);
-    if (!task) return null;
-    const updated = { ...task, ...updates };
-    const taskPath = join(this.projectPaths.tasksDir, `${taskId}.json`);
-    writeFileSync(taskPath, JSON.stringify(updated, null, 2));
-    return updated;
-  }
-
-  pickNextTask() {
-    const tasks = this.getTasks();
-    const completedIds = new Set(
-      Object.entries(this.stateManager.getState().tasks)
-        .filter(([, t]) => t.status === 'done')
-        .map(([id]) => id)
-    );
-
-    return tasks
-      .filter(t => t.status === 'ready' && !this.runningTasks.has(t.id))
-      .filter(t => (t.depends_on || []).every(dep => completedIds.has(dep)))
-      .sort((a, b) => (a.priority || 99) - (b.priority || 99))[0] || null;
-  }
-
-  async runTask(task) {
-    const agents = this.templateManager.getAgents(this.projectId);
-    const pipelines = this.templateManager.getPipelines(this.projectId);
-    const pipelineName = task.pipeline || this.config.defaults?.pipeline || 'default';
-    const pipeline = resolvePipeline(pipelineName, pipelines, task.stage_overrides, this.config.defaults);
-
-    this.runningTasks.add(task.id);
-    this.stateManager.registerTask(task.id, { name: task.name, pipeline: pipelineName });
-    this.stateManager.updateTaskStatus(task.id, 'in_progress');
-    this.updateTask(task.id, { status: 'in_progress' });
-
-    // Determine working directory
-    const workingDir = task.working_dir || '.';
-    let cwd = join(this.projectPath, workingDir);
-    let worktreePath = null;
-
-    if (this.worktreeManager && existsSync(join(cwd, '.git'))) {
-      worktreePath = this.worktreeManager.create(task.id);
-      cwd = worktreePath;
-    }
-
-    const logPath = join(this.projectPaths.logsDir, `${task.id}.log`);
-
-    const sequencer = new StageSequencer({
-      stages: pipeline.stages,
-      createRunner: (stage) => {
-        const agentDef = agents[stage.agent];
-        if (!agentDef) throw new Error(`Agent not found: ${stage.agent}`);
-
-        const context = buildTemplateContext(task, stage, pipeline, this.projectPaths);
-        const resolvedPrompt = resolveTemplate(agentDef.system_prompt || '', context);
-
-        const runner = new AgentRunner({
-          ...agentDef,
-          system_prompt: resolvedPrompt,
-          timeout: stage.timeout,
-          stuck_timeout: this.config.defaults?.stuck_timeout,
-        });
-
-        runner.on('status', (s) => this.stateManager.updateLiveProgress(task.id, s));
-        runner.on('output', () => this.stateManager.persist());
-
-        return { run: () => runner.run(task.spec || task.description || task.name, { cwd, logPath }) };
-      },
-      onStageStart: async (stage, attempt) => {
-        this.stateManager.startStage(task.id, { stage: stage.stage, agent: stage.agent });
-        this.stateManager.persist();
-      },
-      onStageComplete: async (stage, result, attempt) => {
-        this.stateManager.completeStage(task.id, result.status, result.summary);
-        this.stateManager.persist();
-      },
-    });
-
-    const result = await sequencer.run();
-
-    const finalStatus = result.status === 'success' ? 'done' : 'failed';
-    this.stateManager.updateTaskStatus(task.id, finalStatus);
-    this.stateManager.persist();
-    this.updateTask(task.id, { status: finalStatus });
-
-    // Create PR if worktree has changes
-    if (worktreePath && this.worktreeManager.hasChanges(task.id)) {
-      const summary = result.results.map(r => `- ${r.stage}: ${r.summary}`).join('\n');
-      const prUrl = this.worktreeManager.createPR(task.id, task.name, summary);
-      if (prUrl) this.stateManager.setPrUrl(task.id, prUrl);
-      this.stateManager.persist();
-    }
-
-    // Cleanup worktree
-    if (worktreePath) {
-      this.worktreeManager.remove(task.id);
-    }
-
-    this.runningTasks.delete(task.id);
-    return result;
-  }
-
-  async startLoop(interval = 5000) {
-    this.running = true;
-
-    while (this.running) {
-      const maxParallel = this.config.defaults?.max_parallel || 1;
-      const available = maxParallel - this.runningTasks.size;
-
-      for (let i = 0; i < available; i++) {
-        const task = this.pickNextTask();
-        if (!task) break;
-        // Fire and forget — runs in parallel
-        this.runTask(task).catch(err => {
-          console.error(`Task ${task.id} failed:`, err);
-        });
-      }
-
-      await new Promise(r => setTimeout(r, interval));
-    }
-  }
-
-  stop() {
-    this.running = false;
-  }
-}

package/runner/main/paths.js

@@ -1,36 +0,0 @@
-import { join } from 'path';
-import { homedir, platform } from 'os';
-
-export class Paths {
-  constructor(root) {
-    this.root = root || Paths.defaultRoot();
-  }
-
-  static defaultRoot() {
-    if (platform() === 'darwin') {
-      return join(homedir(), 'Library', 'Application Support', 'Specd');
-    }
-    return join(homedir(), '.config', 'specd');
-  }
-
-  get db() { return join(this.root, 'db.json'); }
-  get config() { return join(this.root, 'config.json'); }
-  get templatesDir() { return join(this.root, 'templates'); }
-  get agentTemplatesDir() { return join(this.root, 'templates', 'agents'); }
-  get pipelineTemplatesDir() { return join(this.root, 'templates', 'pipelines'); }
-  get projectsDir() { return join(this.root, 'projects'); }
-  get electronDir() { return join(this.root, 'electron'); }
-
-  forProject(projectId) {
-    const dir = join(this.root, 'projects', projectId);
-    return {
-      dir,
-      projectJson: join(dir, 'project.json'),
-      statusJson: join(dir, 'status.json'),
-      tasksDir: join(dir, 'tasks'),
-      logsDir: join(dir, 'logs'),
-      agentsDir: join(dir, 'agents'),
-      pipelinesDir: join(dir, 'pipelines'),
-    };
-  }
-}

package/runner/main/pipeline/resolver.js

@@ -1,20 +0,0 @@
-// runner/main/pipeline/resolver.js
-export function resolvePipeline(pipelineName, pipelines, stageOverrides, defaults) {
-  const pipeline = pipelines[pipelineName];
-  if (!pipeline) throw new Error(`Pipeline not found: ${pipelineName}`);
-
-  const stages = pipeline.stages.map((stage, index) => {
-    const override = stageOverrides?.[stage.stage] || {};
-    return {
-      ...stage,
-      ...override,
-      timeout: stage.timeout || defaults?.timeout || 3600,
-      on_fail: stage.on_fail || defaults?.failure_policy || 'skip',
-      max_retries: stage.max_retries || 0,
-      index: index + 1,
-      total: pipeline.stages.length,
-    };
-  });
-
-  return { name: pipelineName, stages };
-}

package/runner/main/pipeline/sequencer.js

@@ -1,42 +0,0 @@
-// runner/main/pipeline/sequencer.js
-export class StageSequencer {
-  constructor({ stages, createRunner, onStageStart, onStageComplete }) {
-    this.stages = stages;
-    this.createRunner = createRunner;
-    this.onStageStart = onStageStart;
-    this.onStageComplete = onStageComplete;
-  }
-
-  async run() {
-    const results = [];
-
-    for (const stage of this.stages) {
-      const maxAttempts = 1 + (stage.max_retries || 0);
-      let stageResult = null;
-
-      for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-        const runner = this.createRunner(stage);
-        await this.onStageStart(stage, attempt);
-
-        try {
-          stageResult = await runner.run('');
-        } catch (err) {
-          stageResult = { status: 'failure', summary: err.message };
-        }
-
-        await this.onStageComplete(stage, stageResult, attempt);
-
-        if (stageResult.status === 'success') break;
-        if (stageResult.status === 'failure' && stage.on_fail !== 'retry') break;
-      }
-
-      results.push({ stage: stage.stage, ...stageResult });
-
-      if (stageResult.status !== 'success' && stage.critical) {
-        return { status: 'failure', results, failedStage: stage.stage };
-      }
-    }
-
-    return { status: 'success', results };
-  }
-}

package/runner/main/server/api.js

@@ -1,125 +0,0 @@
-// runner/main/server/api.js
-import { Router } from 'express';
-import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
-import { randomUUID } from 'crypto';
-
-export function createApiRouter(getContext) {
-  const router = Router();
-
-  // Find project by path (for skill auto-detection) — must be before :id routes
-  router.get('/projects/by-path', (req, res) => {
-    const { db } = getContext();
-    const folderPath = req.query.path;
-    if (!folderPath) return res.status(400).json({ error: 'path query param required' });
-    const project = db.findByPath(folderPath);
-    if (!project) return res.status(404).json({ error: 'No project matches this path' });
-    res.json(project);
-  });
-
-  // List projects
-  router.get('/projects', (req, res) => {
-    const { db, orchestrators } = getContext();
-    const projects = db.list().map(p => {
-      const orch = orchestrators.get(p.id);
-      const tasks = orch ? orch.getTasks() : [];
-      return {
-        ...p,
-        taskCounts: {
-          total: tasks.length,
-          ready: tasks.filter(t => t.status === 'ready').length,
-          running: tasks.filter(t => t.status === 'in_progress').length,
-          done: tasks.filter(t => t.status === 'done').length,
-          failed: tasks.filter(t => t.status === 'failed').length,
-        },
-      };
-    });
-    res.json(projects);
-  });
-
-  // Global status
-  router.get('/status', (req, res) => {
-    const { orchestrators } = getContext();
-    const status = {};
-    for (const [id, orch] of orchestrators) {
-      status[id] = orch.stateManager.getState();
-    }
-    res.json(status);
-  });
-
-  // Project status
-  router.get('/projects/:id/status', (req, res) => {
-    const { orchestrators } = getContext();
-    const orch = orchestrators.get(req.params.id);
-    if (!orch) return res.status(404).json({ error: 'Project not found' });
-    res.json(orch.stateManager.getState());
-  });
-
-  // List tasks
-  router.get('/projects/:id/tasks', (req, res) => {
-    const { orchestrators } = getContext();
-    const orch = orchestrators.get(req.params.id);
-    if (!orch) return res.status(404).json({ error: 'Project not found' });
-    res.json(orch.getTasks());
-  });
-
-  // Get task
-  router.get('/projects/:id/tasks/:taskId', (req, res) => {
-    const { orchestrators } = getContext();
-    const orch = orchestrators.get(req.params.id);
-    if (!orch) return res.status(404).json({ error: 'Project not found' });
-    const task = orch.getTask(req.params.taskId);
-    if (!task) return res.status(404).json({ error: 'Task not found' });
-    res.json(task);
-  });
-
-  // Create task
-  router.post('/projects/:id/tasks', (req, res) => {
-    const { orchestrators } = getContext();
-    const orch = orchestrators.get(req.params.id);
-    if (!orch) return res.status(404).json({ error: 'Project not found' });
-    if (!req.body.name) return res.status(400).json({ error: 'name is required' });
-
-    const task = {
-      id: req.body.id || `task-${randomUUID().slice(0, 6)}`,
-      name: req.body.name,
-      description: req.body.description || '',
-      project_id: req.params.id,
-      working_dir: req.body.working_dir || '.',
-      pipeline: req.body.pipeline || 'default',
-      status: req.body.status || 'ready',
-      priority: req.body.priority || 10,
-      depends_on: req.body.depends_on || [],
-      spec: req.body.spec || '',
-      created_at: new Date().toISOString(),
-    };
-
-    orch.createTask(task);
-    res.status(201).json(task);
-  });
-
-  // Retry task
-  router.post('/projects/:id/tasks/:taskId/retry', (req, res) => {
-    const { orchestrators } = getContext();
-    const orch = orchestrators.get(req.params.id);
-    if (!orch) return res.status(404).json({ error: 'Project not found' });
-
-    const task = orch.updateTask(req.params.taskId, { status: 'ready' });
-    if (!task) return res.status(404).json({ error: 'Task not found' });
-    res.json(task);
-  });
-
-  // Task logs
-  router.get('/projects/:id/tasks/:taskId/logs', (req, res) => {
-    const { paths } = getContext();
-    const logPath = join(paths.forProject(req.params.id).logsDir, `${req.params.taskId}.log`);
-    if (!existsSync(logPath)) return res.status(404).json({ error: 'Log not found' });
-
-    const content = readFileSync(logPath, 'utf-8');
-    const lines = content.split('\n');
-    const tail = parseInt(req.query.tail) || 200;
-    res.json({ lines: lines.slice(-tail) });
-  });
-
-  return router;
-}

package/runner/main/server/index.js

@@ -1,33 +0,0 @@
-// runner/main/server/index.js
-import express from 'express';
-import { createServer as createHttpServer } from 'http';
-import { createApiRouter } from './api.js';
-import { WsBroadcaster } from './websocket.js';
-
-export function createServer(getContext) {
-  const app = express();
-  app.use(express.json());
-  app.use('/api', createApiRouter(getContext));
-
-  const httpServer = createHttpServer(app);
-  const broadcaster = new WsBroadcaster(httpServer);
-
-  return {
-    start(port) {
-      return new Promise((resolve) => {
-        httpServer.listen(port, '127.0.0.1', () => {
-          console.log(`Specd API server on http://127.0.0.1:${port}`);
-          resolve();
-        });
-      });
-    },
-    stop() {
-      broadcaster.close();
-      httpServer.close();
-    },
-    broadcaster,
-    wireOrchestrator(orch) {
-      orch.on('change', (event) => broadcaster.broadcast(event));
-    },
-  };
-}