ai-maestro 1.0.0

package/src/tasks.mjs

@@ -0,0 +1,134 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { CONFIG } from './config.mjs';
+import { readJsonSafe, writeJsonWithBackup } from './files.mjs';
+import { stampSchemaVersion, validateTask } from './schema.mjs';
+
+const tasksFilePath = path.join(CONFIG.maestroPath, 'TASKS.json');
+const priorityRank = { high: 0, medium: 1, low: 2 };
+const activeStatuses = new Set(['pending', 'in_progress', 'failed', 'blocked']);
+
+export async function getTasks() {
+  return readJsonSafe(tasksFilePath, []);
+}
+
+export async function saveTasks(tasks) {
+  for (const task of tasks) {
+    const result = validateTask(task);
+    if (!result.ok) {
+      console.warn('Task #' + task.id + ' failed schema validation: ' + result.errors.join(', '));
+    }
+  }
+  await writeJsonWithBackup(tasksFilePath, tasks);
+}
+
+export function sortRunnableTasks(tasks) {
+  return [...tasks].sort((a, b) => {
+    const pa = priorityRank[a.priority] ?? 9;
+    const pb = priorityRank[b.priority] ?? 9;
+    if (pa !== pb) return pa - pb;
+    return String(a.createdAt || '').localeCompare(String(b.createdAt || ''));
+  });
+}
+
+export function getNextTask(tasks) {
+  return sortRunnableTasks(tasks.filter(task => task.status === 'pending'))[0] || null;
+}
+
+function archiveTimestamp() {
+  const now = new Date();
+  const pad = value => String(value).padStart(2, '0');
+  return String(now.getFullYear()) + pad(now.getMonth() + 1) + pad(now.getDate()) + '-' + pad(now.getHours()) + pad(now.getMinutes()) + pad(now.getSeconds());
+}
+
+async function uniqueArchivePath(basePath) {
+  let candidate = basePath;
+  let suffix = 1;
+  while (true) {
+    try {
+      await fs.access(candidate);
+      candidate = basePath.replace(/\.json$/, '-' + suffix + '.json');
+      suffix += 1;
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return candidate;
+      }
+      throw error;
+    }
+  }
+}
+
+export async function archiveTasks(predicate, reason) {
+  const tasks = await getTasks();
+  const archived = tasks.filter(predicate);
+  if (archived.length === 0) {
+    return { archived: [], archivePath: null, remaining: tasks };
+  }
+  const remaining = tasks.filter(task => !predicate(task));
+  const archiveDir = path.join(CONFIG.maestroPath, 'archive');
+  await fs.mkdir(archiveDir, { recursive: true });
+  const archivePath = await uniqueArchivePath(path.join(archiveDir, 'tasks-' + archiveTimestamp() + '.json'));
+  const archivedAt = new Date().toISOString();
+  await fs.writeFile(archivePath, JSON.stringify({ archivedAt, reason, tasks: archived.map(task => ({ ...task, status: 'archived', archivedAt, archiveReason: reason })) }, null, 2));
+  await saveTasks(remaining);
+  return { archived, archivePath, remaining };
+}
+
+export async function archiveActiveTasksBeforePlan() {
+  const tasks = await getTasks();
+  const archived = tasks.filter(task => activeStatuses.has(task.status));
+  if (archived.length === 0) {
+    return { archived: [], archivePath: null, remaining: tasks };
+  }
+  const remaining = tasks.filter(task => !activeStatuses.has(task.status));
+  const archiveDir = path.join(CONFIG.maestroPath, 'archive');
+  await fs.mkdir(archiveDir, { recursive: true });
+  const archivePath = await uniqueArchivePath(path.join(archiveDir, 'tasks-before-plan-' + archiveTimestamp() + '.json'));
+  const archivedAt = new Date().toISOString();
+  await fs.writeFile(archivePath, JSON.stringify({ archivedAt, reason: 'before-plan', tasks: archived.map(task => ({ ...task, status: 'archived', archivedAt, archiveReason: 'before-plan' })) }, null, 2));
+  await saveTasks(remaining);
+  return { archived, archivePath, remaining };
+}
+
+export async function addTask(description, fields = {}) {
+  const tasks = await getTasks();
+  const now = new Date().toISOString();
+  const newTask = stampSchemaVersion({
+    id: tasks.length > 0 ? Math.max(...tasks.map(t => t.id)) + 1 : 1,
+    title: fields.title || description,
+    description,
+    status: fields.status || 'pending',
+    priority: fields.priority || 'medium',
+    engine: fields.engine || 'codex9',
+    files: fields.files || [],
+    acceptance: fields.acceptance || [],
+    requestKind: fields.requestKind || null,
+    sourceRequest: fields.sourceRequest || null,
+    sourceSpec: fields.sourceSpec || null,
+    ...(fields.parentTaskId !== undefined ? { parentTaskId: fields.parentTaskId } : {}),
+    ...(fields.subtaskId !== undefined ? { subtaskId: fields.subtaskId } : {}),
+    ...(fields.blockedBy !== undefined ? { blockedBy: fields.blockedBy } : {}),
+    createdAt: now,
+    updatedAt: now
+  });
+  tasks.push(newTask);
+  await saveTasks(tasks);
+  return newTask;
+}
+
+export async function updateTaskStatus(taskId, status) {
+  const tasks = await getTasks();
+  const taskIndex = tasks.findIndex(task => String(task.id) === String(taskId));
+  if (taskIndex !== -1) {
+    tasks[taskIndex].status = status;
+    tasks[taskIndex].updatedAt = new Date().toISOString();
+    await saveTasks(tasks);
+    return true;
+  }
+  return false;
+}
+
+export async function getTaskById(taskId) {
+  const tasks = await getTasks();
+  return tasks.find(task => String(task.id) === String(taskId)) || null;
+}

package/src/ui/commands.mjs

@@ -0,0 +1,76 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { spawn } from 'child_process';
+import { CONFIG } from '../config.mjs';
+import { summarizeText } from '../format.mjs';
+
+export const UI_COMMANDS = {
+  doctor: { args: ['bin/maestro.mjs', 'doctor'] },
+  'codex-home': { args: ['bin/maestro.mjs', 'codex-home'] },
+  'codex-test': { args: ['bin/maestro.mjs', 'codex-test'] },
+  'task-list': { args: ['bin/maestro.mjs', 'task', 'list'] },
+  'task-next': { args: ['bin/maestro.mjs', 'task', 'next'] },
+  'run-one': { args: ['bin/maestro.mjs', 'run-one'] },
+  'run-all-limit-3': { args: ['bin/maestro.mjs', 'run-all', '--limit', '3'] },
+  'run-task': { args: taskId => ['bin/maestro.mjs', 'run-task', String(taskId)] },
+  'task-pending': { args: taskId => ['bin/maestro.mjs', 'task', 'pending', String(taskId)] },
+  checkpoint: { args: ['bin/maestro.mjs', 'checkpoint'] },
+  handoff: { args: ['bin/maestro.mjs', 'handoff'] },
+  stats: { args: ['bin/maestro.mjs', 'stats'] },
+  'release-check': { args: ['bin/maestro.mjs', 'release-check'] },
+  'schema-check': { args: ['bin/maestro.mjs', 'schema-check'] }
+};
+
+export function normalizePositiveInteger(value, name = 'value') {
+  if (typeof value !== 'number' || !Number.isInteger(value) || value <= 0) {
+    throw new Error(name + ' must be a positive integer');
+  }
+  return value;
+}
+
+export function getUiCommandDescriptor(commandId, payload = {}) {
+  const descriptor = UI_COMMANDS[commandId];
+  if (!descriptor) {
+    throw new Error('Unknown UI command: ' + commandId);
+  }
+  if (typeof descriptor.args === 'function') {
+    const taskId = normalizePositiveInteger(payload.taskId, 'taskId');
+    return { command: 'node', args: descriptor.args(taskId), taskId };
+  }
+  return { command: 'node', args: descriptor.args, taskId: null };
+}
+
+async function appendUiRun(entry, projectRoot) {
+  await fs.mkdir(path.join(projectRoot, CONFIG.maestroPath), { recursive: true });
+  await fs.appendFile(path.join(projectRoot, CONFIG.maestroPath, 'ui-runs.jsonl'), JSON.stringify(entry) + '\n');
+}
+
+export async function runUiCommand(commandId, payload = {}, projectRoot = process.cwd()) {
+  const descriptor = getUiCommandDescriptor(commandId, payload);
+  const startedAt = new Date().toISOString();
+  const startedMs = Date.now();
+  const result = await new Promise(resolve => {
+    const child = spawn(descriptor.command, descriptor.args, { cwd: projectRoot, shell: false, windowsHide: true });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', chunk => { stdout += chunk.toString(); });
+    child.stderr.on('data', chunk => { stderr += chunk.toString(); });
+    child.on('error', error => resolve({ exitCode: 1, stdout, stderr: stderr + error.message }));
+    child.on('close', code => resolve({ exitCode: code ?? 1, stdout, stderr }));
+  });
+  const status = result.exitCode === 0 ? 'completed' : 'failed';
+  const entry = {
+    timestamp: startedAt,
+    commandId,
+    taskId: descriptor.taskId,
+    args: descriptor.args,
+    exitCode: result.exitCode,
+    status,
+    summary: summarizeText(result.stdout || result.stderr || commandId, 260),
+    stdout: summarizeText(result.stdout, 1400),
+    stderr: summarizeText(result.stderr, 1400),
+    durationMs: Date.now() - startedMs
+  };
+  await appendUiRun(entry, projectRoot);
+  return entry;
+}

package/src/ui/events.mjs

@@ -0,0 +1,45 @@
+import fs from 'fs/promises';
+import { getUiWatchFiles, readUiState } from './state.mjs';
+
+async function fileSignature(files) {
+  const stats = await Promise.all(files.map(async file => {
+    try {
+      const stat = await fs.stat(file);
+      return file + ':' + stat.mtimeMs + ':' + stat.size;
+    } catch (error) {
+      if (error.code === 'ENOENT') return file + ':missing';
+      throw error;
+    }
+  }));
+  return stats.join('|');
+}
+
+function writeSse(res, event, data) {
+  res.write('event: ' + event + '\n');
+  res.write('data: ' + JSON.stringify(data) + '\n\n');
+}
+
+export async function handleEvents(req, res, projectRoot = process.cwd()) {
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    Connection: 'keep-alive'
+  });
+  const files = getUiWatchFiles(projectRoot);
+  let signature = await fileSignature(files);
+  writeSse(res, 'state', await readUiState(projectRoot));
+  const interval = setInterval(async () => {
+    try {
+      const nextSignature = await fileSignature(files);
+      if (nextSignature !== signature) {
+        signature = nextSignature;
+        writeSse(res, 'state', await readUiState(projectRoot));
+      } else {
+        writeSse(res, 'heartbeat', { timestamp: new Date().toISOString() });
+      }
+    } catch (error) {
+      writeSse(res, 'error', { message: error.message });
+    }
+  }, 1500);
+  req.on('close', () => clearInterval(interval));
+}