ai-maestro 1.0.0

package/bin/maestro.mjs

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+
+import { acquireLock, releaseLock } from '../src/lock.mjs';
+import {
+  init, status, plan, startCommand, continueCommand, doctor, releaseCheck, stats, checkpoint, handoff, schemaCheck, printHelp, providerHealthCommand
+} from '../src/session-commands.mjs';
+import { runTask, runOne, runAll, retry, taskCommand, reconcileCrashedTasks } from '../src/task-commands.mjs';
+import { runSerialOrchestration } from '../src/orchestration/orchestration-runtime.mjs';
+import { runTaskWithFailover } from '../src/orchestration/attempt-chain-runtime.mjs';
+import { readinessCommand } from '../src/orchestration/self-hosting-readiness.mjs';
+import { rcCheckCommand } from '../src/orchestration/rc-check.mjs';
+import { readRunArtifact } from '../src/runner.mjs';
+import { redactCredentials } from '../src/format.mjs';
+import {
+  codexHomeCommand, codexHomeDiff, codexHomeInventory, codexHomeProbe, codexHomeRepair,
+  codexCompare, codexTestInvocation, codexDebugCommand, codexSandboxTestCommand
+} from '../src/codex-diagnostics.mjs';
+import { startUiServer } from '../src/ui/server.mjs';
+import {
+  enginesList, enginesShow, enginesHealth, enginesValidate, enginesResearch,
+  routeTask, preflightCommand, orchestraPlan, budgetCommand,
+  statsByEngine, statsByRunKind, statsCost, statsByGateDecision
+} from '../src/orchestration-commands.mjs';
+
+const MUTATING_TASK_SUBCOMMANDS = new Set([
+  'add', 'complete', 'fail', 'pending', 'archive-failed', 'archive-completed', 'clean-test'
+]);
+
+const MUTATING_COMMANDS = new Set([
+  'init', 'start', 'plan', 'run-one', 'run-task', 'orchestrate', 'run-all', 'retry',
+  'recover', 'reconcile', 'checkpoint', 'handoff', 'codex-home-repair'
+]);
+
+function needsLock(command, args) {
+  if (command === 'run-task' && args.includes('--failover')) {
+    return false;
+  }
+  if ((command === 'recover' || command === 'reconcile') && args.includes('--dry-run')) {
+    return false;
+  }
+  if (command === 'task') {
+    return MUTATING_TASK_SUBCOMMANDS.has(args[0]);
+  }
+  return MUTATING_COMMANDS.has(command);
+}
+
+function parseArtifactArgs(args) {
+  let runId = null;
+  let taskId = null;
+  let lines = null;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--task') {
+      taskId = args[++i] || null;
+    } else if (arg === '--lines') {
+      lines = Number.parseInt(args[++i], 10);
+    } else if (!arg.startsWith('--') && !runId) {
+      runId = arg;
+    }
+  }
+  return {
+    runId,
+    taskId,
+    latest: args.includes('--latest'),
+    tail: args.includes('--tail'),
+    lines: Number.isFinite(lines) && lines > 0 ? lines : null
+  };
+}
+
+async function printArtifact(kind, args) {
+  const parsed = parseArtifactArgs(args);
+  const result = await readRunArtifact({ kind, ...parsed });
+  console.log(redactCredentials(result.content));
+}
+
+function parseOrchestrateArgs(args) {
+  let idArg = null;
+  let maxConcurrent;
+  const consumed = new Set();
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '--max-concurrent') {
+      consumed.add(index);
+      consumed.add(index + 1);
+      maxConcurrent = args[index + 1];
+    } else if (arg.startsWith('--max-concurrent=')) {
+      consumed.add(index);
+      maxConcurrent = arg.slice('--max-concurrent='.length);
+    }
+  }
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (!consumed.has(index) && !arg.startsWith('--') && !idArg) {
+      idArg = arg;
+    }
+  }
+  const parallel = args.includes('--parallel');
+  return {
+    idArg,
+    parallel,
+    concurrency: parallel ? { enabled: true, maxConcurrent } : undefined
+  };
+}
+
+async function dispatch(command, args) {
+  switch (command) {
+    case undefined:
+    case 'help':
+    case '--help':
+    case '-h': return printHelp();
+    case 'init': return init();
+    case 'status': return status();
+    case 'start': {
+      const validateWorker = args.includes('--validate-worker');
+      const requestArgs = args.filter(arg => arg !== '--validate-worker');
+      return startCommand(requestArgs.join(' '), { validateWorker });
+    }
+    case 'continue': return continueCommand();
+    case 'doctor': return doctor();
+    case 'provider-health': return providerHealthCommand({ json: args.includes('--json') });
+    case 'rc-check': return rcCheckCommand(args);
+    case 'readiness': return readinessCommand();
+    case 'codex-home': return codexHomeCommand();
+    case 'codex-home-diff': return codexHomeDiff();
+    case 'codex-home-inventory': return codexHomeInventory();
+    case 'codex-home-probe': return codexHomeProbe();
+    case 'codex-home-repair': return codexHomeRepair();
+    case 'codex-compare': return codexCompare();
+    case 'codex-test': return codexTestInvocation();
+    case 'codex-sandbox-test': return codexSandboxTestCommand();
+    case 'codex-debug': return codexDebugCommand();
+    case 'stats': {
+      if (args.includes('--by-engine')) return statsByEngine();
+      if (args.includes('--by-run-kind')) return statsByRunKind();
+      if (args.includes('--cost')) return statsCost();
+      if (args.includes('--by-gate-decision')) return statsByGateDecision();
+      return stats();
+    }
+    case 'engines': {
+      const [sub, subArg] = args;
+      if (sub === 'list' || !sub) return enginesList();
+      if (sub === 'show') return enginesShow(subArg);
+      if (sub === 'health') return enginesHealth();
+      if (sub === 'validate') return enginesValidate(subArg);
+      if (sub === 'research') return enginesResearch();
+      console.log('Usage: maestro engines list | show <id> | health | validate <id> | research');
+      return;
+    }
+    case 'route-task': return routeTask(args[0]);
+    case 'preflight': return preflightCommand(args[0]);
+    case 'orchestra-plan': {
+      const dryRun = args.includes('--dry-run');
+      const idArg = args.find(arg => arg !== '--dry-run');
+      return orchestraPlan(idArg, { dryRun });
+    }
+    case 'budget': return budgetCommand();
+    case 'release-check': return releaseCheck();
+    case 'schema-check': return schemaCheck();
+    case 'run-log': return printArtifact('log', args);
+    case 'report': return printArtifact('report', args);
+    case 'plan': return args[0] ? plan(args.join(' ')) : console.log('Usage: maestro plan "<request>"');
+    case 'run-one': {
+      if (args.includes('--dry-run')) return orchestraPlan(undefined, { dryRun: true });
+      return runOne({ quiet: args.includes('--quiet'), force: args.includes('--force'), verbose: args.includes('--verbose'), debug: args.includes('--debug') });
+    }
+    case 'run-task': {
+      if (args.includes('--failover')) {
+        const idArg = args.find(arg => !arg.startsWith('--'));
+        const simulateArg = args.find(arg => arg.startsWith('--simulate-failure='));
+        const simulateFailure = simulateArg ? simulateArg.slice('--simulate-failure='.length) : null;
+        if (!idArg) return console.log('Usage: maestro run-task <id> --failover [--dry-run] [--resume] [--force]');
+        const result = await runTaskWithFailover(idArg, {
+          dryRun: args.includes('--dry-run'),
+          resume: args.includes('--resume'),
+          force: args.includes('--force'),
+          verbose: args.includes('--verbose'),
+          debug: args.includes('--debug'),
+          simulateFailure
+        });
+        console.log(redactCredentials(JSON.stringify(result, null, 2)));
+        if (result && result.status !== 'completed' && result.status !== 'completed_with_warnings' && result.dryRun !== true) {
+          process.exitCode = 1;
+        }
+        return;
+      }
+      if (args.includes('--dry-run')) return orchestraPlan(args.find(arg => arg !== '--dry-run' && arg !== '--force' && arg !== '--verbose' && arg !== '--debug'), { dryRun: true });
+      const idArg = args.find(arg => !arg.startsWith('--'));
+      return idArg
+        ? runTask(idArg, { quiet: args.includes('--quiet'), force: args.includes('--force'), verbose: args.includes('--verbose'), debug: args.includes('--debug') })
+        : console.log('Usage: maestro run-task <id> [--quiet] [--verbose] [--debug] [--dry-run] [--force]');
+    }
+    case 'canary': {
+      if (!args[0]) return console.log('Usage: maestro canary <path>');
+      const { canaryCommand } = await import('../src/orchestration/self-hosting-canary.mjs');
+      return canaryCommand(args[0]);
+    }
+    case 'orchestrate': {
+      const parsed = parseOrchestrateArgs(args);
+      if (!parsed.idArg) return console.log('Usage: maestro orchestrate <id> [--real] [--force] [--parallel] [--max-concurrent=N]');
+      const result = await runSerialOrchestration({
+        taskId: parsed.idArg,
+        mode: args.includes('--real') ? 'real' : 'dry-run',
+        force: args.includes('--force'),
+        suppressOutput: args.includes('--quiet'),
+        concurrency: parsed.concurrency
+      });
+      console.log(redactCredentials(JSON.stringify(result, null, 2)));
+      return;
+    }
+    case 'run-all': return runAll({ quiet: args.includes('--quiet'), force: args.includes('--force'), verbose: args.includes('--verbose'), debug: args.includes('--debug'), dryRun: args.includes('--dry-run') });
+    case 'recover':
+    case 'reconcile': return reconcileCrashedTasks({ dryRun: args.includes('--dry-run') });
+    case 'retry': return args[0] ? retry(args[0]) : console.log('Usage: maestro retry <id>');
+    case 'task': return taskCommand(args);
+    case 'checkpoint': return checkpoint();
+    case 'handoff': return handoff();
+    case 'ui': {
+      const result = await startUiServer();
+      console.log('Maestro UI: ' + result.url);
+      return new Promise(() => {});
+    }
+    default:
+      console.log('Unknown command. Available commands: init, status, start, continue, doctor, provider-health, rc-check, codex-home, codex-home-diff, codex-home-inventory, codex-home-probe, codex-home-repair, codex-compare, codex-test, codex-sandbox-test, codex-debug, stats, release-check, readiness, canary, schema-check, run-log, report, plan, run-one, run-task, orchestrate, run-all, recover, reconcile, retry, task, checkpoint, handoff, ui, engines, route-task, preflight, orchestra-plan, budget');
+  }
+}
+
+async function main() {
+  const command = process.argv[2];
+  const args = process.argv.slice(3);
+  const locked = needsLock(command, args);
+  if (locked) {
+    await acquireLock(command + (args.length ? ' ' + args.join(' ') : ''));
+  }
+  try {
+    await dispatch(command, args);
+  } finally {
+    if (locked) {
+      await releaseLock();
+    }
+  }
+}
+
+main().catch(error => {
+  console.error(error.message || error);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "ai-maestro",
+  "version": "1.0.0",
+  "description": "Project-local multi-agent orchestration CLI backed by ai-universal-memory.",
+  "type": "module",
+  "license": "ISC",
+  "author": "Kinzart",
+  "bin": {
+    "maestro": "bin/maestro.mjs"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "check": "node --check bin/maestro.mjs && node --check src/config.mjs && node --check src/shell.mjs && node --check src/schema.mjs && node --check src/lock.mjs && node --check src/memory-log.mjs && node --check src/format.mjs && node --check src/codex-home-inspect.mjs && node --check src/codex-diagnostics.mjs && node --check src/task-commands.mjs && node --check src/session-commands.mjs && node --check src/codex-home.mjs && node --check src/commands.mjs && node --check src/debug.mjs && node --check src/encoding-guard.mjs && node --check src/ui/server.mjs && node --check src/ui/state.mjs && node --check src/ui/commands.mjs && node --check src/ui/events.mjs && node --check src/engines/engine.mjs && node --check src/engines/codex-engine.mjs && node --check src/engines/ai-router-engine.mjs && node --check src/engines/registry.mjs && node --check src/smart-planner.mjs && node --check src/run-diagnostics.mjs && node --check src/planner.mjs && node --check src/workspace-diff.mjs && node --check src/runner.mjs && node --check src/tasks.mjs && node --check src/usage.mjs && node --check src/orchestration-commands.mjs && node --check src/orchestration/capability-registry.mjs && node --check src/orchestration/task-classifier.mjs && node --check src/orchestration/preflight.mjs && node --check src/orchestration/engine-selector.mjs && node --check src/orchestration/sector-managers.mjs && node --check src/orchestration/delegation-manager.mjs && node --check src/orchestration/fallback-graph.mjs && node --check src/orchestration/budget-manager.mjs && node --check src/orchestration/verifier.mjs && node --check src/orchestration/engine-history.mjs && node --check src/orchestration/engine-policy.mjs && node --check src/orchestration/runtime-gate.mjs && node --check src/orchestration/execution-context.mjs && node --check src/orchestration/failure-classifier.mjs && node --check src/orchestration/failure-evidence.mjs && node --check src/orchestration/provider-health.mjs && node --check src/orchestration/fallback-recommendation.mjs && node --check src/orchestration/provider-router.mjs && node --check src/orchestration/attempt-chain-runtime.mjs && node --check src/orchestration/fallback-chain-trail.mjs && node --check src/orchestration/fallback-chain-lock.mjs && node --check src/orchestration/fallback-executor.mjs && node --check src/orchestration/host-validation.mjs && node --check src/orchestration/spec-planner.mjs && node --check src/orchestration/deployment-intent.mjs && node --check src/orchestration/subtask-planner.mjs && node --check src/orchestration/delegation-executor.mjs && node --check src/orchestration/file-conflict-detector.mjs && node --check src/orchestration/consolidator.mjs && node --check src/orchestration/orchestration-loop.mjs && node --check src/orchestration/orchestration-scheduler.mjs && node --check src/orchestration/orchestration-runtime.mjs && node --check src/orchestration/orchestration-trail.mjs && node --check src/orchestration/self-hosting-readiness.mjs && node --check src/orchestration/self-hosting-canary.mjs && node --check src/orchestration/rc-policy.mjs && node --check src/orchestration/rc-check-adapters.mjs && node --check src/orchestration/rc-check.mjs",
+    "test": "node --test tests/*.test.mjs"
+  },
+  "keywords": [
+    "ai",
+    "cli",
+    "codex",
+    "agents",
+    "memory"
+  ]
+}

package/src/checkpoint.mjs

@@ -0,0 +1,102 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { CONFIG } from './config.mjs';
+import { execFileRaw } from './shell.mjs';
+import { getTasks } from './tasks.mjs';
+import { getRecentRuns } from './runner.mjs';
+import { writeTextWithBackup } from './files.mjs';
+
+const checkpointFilePath = path.join(CONFIG.maestroPath, 'CHECKPOINT.md');
+
+async function readLastLines(filePath, limit = 5) {
+  try {
+    const content = await fs.readFile(filePath, 'utf-8');
+    return content.split(/\r?\n/).filter(Boolean).slice(-limit);
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return [];
+    }
+    throw error;
+  }
+}
+
+export async function generateCheckpoint() {
+  let checkpointContent = '# AI Maestro Checkpoint\n\n';
+  checkpointContent += '## Date and Time\n';
+  checkpointContent += '- ' + new Date().toISOString() + '\n\n';
+
+  try {
+    const branch = await execFileRaw('git', ['branch', '--show-current'], { quiet: true });
+    const status = await execFileRaw('git', ['status', '--porcelain'], { quiet: true });
+    checkpointContent += '## Git\n';
+    checkpointContent += '- Branch: ' + (branch.stdout.trim() || 'unknown') + '\n';
+    const gitStatusOutput = status.stdout.trim();
+    if (gitStatusOutput.trim()) {
+      checkpointContent += '- Uncommitted changes:\n\n```text\n' + gitStatusOutput + '\n```\n\n';
+    } else {
+      checkpointContent += '- No uncommitted changes.\n\n';
+    }
+  } catch (error) {
+    checkpointContent += '## Git\n- Git not found or current directory is not a Git repository.\n\n';
+  }
+
+  const tasks = await getTasks();
+  const pendingTasks = tasks.filter(task => task.status === 'pending');
+  const inProgressTasks = tasks.filter(task => task.status === 'in_progress');
+  const completedTasks = tasks.filter(task => task.status === 'completed');
+  const failedTasks = tasks.filter(task => task.status === 'failed');
+
+
+  checkpointContent += '## Tasks Overview\n';
+  checkpointContent += '- Total tasks: ' + tasks.length + '\n';
+  checkpointContent += '- Pending: ' + pendingTasks.length + '\n';
+  checkpointContent += '- In Progress: ' + inProgressTasks.length + '\n';
+  checkpointContent += '- Completed: ' + completedTasks.length + '\n';
+  checkpointContent += '- Failed: ' + failedTasks.length + '\n\n';
+
+  const groups = [
+    ['Pending Tasks', pendingTasks],
+    ['In Progress Tasks', inProgressTasks],
+    ['Failed Tasks', failedTasks]
+  ];
+  for (const [title, group] of groups) {
+    if (group.length > 0) {
+      checkpointContent += '### ' + title + '\n';
+      group.forEach(task => {
+        checkpointContent += '- #' + task.id + ' ' + (task.title || task.description) + '\n';
+      });
+      checkpointContent += '\n';
+    }
+  }
+
+  const recentRuns = await getRecentRuns(5);
+  checkpointContent += '## Recent Runs\n';
+  if (recentRuns.length === 0) {
+    checkpointContent += '- No runs logged yet.\n\n';
+  } else {
+    for (const run of recentRuns) {
+      checkpointContent += '- Task #' + run.taskId + ' ' + run.status + ' at ' + (run.endTime || run.startTime || 'unknown') + '\n';
+    }
+    checkpointContent += '\n';
+  }
+
+  const recentEvents = await readLastLines(path.join(CONFIG.memoryPath, 'events.jsonl'), 5);
+  checkpointContent += '## Recent Memory Events\n';
+  if (recentEvents.length === 0) {
+    checkpointContent += '- No events found.\n\n';
+  } else {
+    for (const event of recentEvents) {
+      checkpointContent += '- `' + event.replace(/`/g, '') + '`\n';
+    }
+    checkpointContent += '\n';
+  }
+
+  checkpointContent += '## Recommended Commands\n';
+  checkpointContent += '- maestro status\n';
+  checkpointContent += '- maestro doctor\n';
+  checkpointContent += '- maestro run-one\n';
+  checkpointContent += '- maestro handoff\n\n';
+  
+  await writeTextWithBackup(checkpointFilePath, checkpointContent);
+  return checkpointContent;
+}