ai-maestro 1.0.0

package/src/orchestration-commands.mjs

@@ -0,0 +1,279 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { CONFIG } from './config.mjs';
+import { getTaskById, getTasks, getNextTask } from './tasks.mjs';
+import { getEngine } from './engines/registry.mjs';
+import { classifyTask } from './orchestration/task-classifier.mjs';
+import {
+  listEngineRecords, getEngineRecord, describeEngine, getEnginesFilePath
+} from './orchestration/capability-registry.mjs';
+import { runPreflight } from './orchestration/preflight.mjs';
+import { selectEngine, selectEngineWithPreflight } from './orchestration/engine-selector.mjs';
+import { planSectorWork } from './orchestration/sector-managers.mjs';
+import { buildDelegationPlan, DELEGATION_LIMITS } from './orchestration/delegation-manager.mjs';
+import { loadFallbackGraph } from './orchestration/fallback-graph.mjs';
+import { loadBudget, evaluateBudget } from './orchestration/budget-manager.mjs';
+import { checkEnginePolicy } from './orchestration/engine-policy.mjs';
+import { summarizeHistoryByEngine } from './orchestration/engine-history.mjs';
+import { getUsageSummary } from './usage.mjs';
+
+function printJson(value) {
+  console.log(JSON.stringify(value, null, 2));
+}
+
+// ---- maestro engines ... ----------------------------------------------
+
+export async function enginesList() {
+  const engines = await listEngineRecords();
+  if (engines.length === 0) {
+    console.log('No engines found in ' + getEnginesFilePath() + '.');
+    return;
+  }
+  for (const engine of engines) {
+    const costClass = engine.cost ? engine.cost.class : 'unknown';
+    console.log(
+      '- ' + engine.id + ' [' + (engine.enabled ? 'enabled' : 'disabled') + ', ' +
+      (engine.validated ? 'validated' : 'unvalidated') + ', cost=' + costClass + ', roles=' +
+      (engine.roles && engine.roles.length ? engine.roles.join('/') : 'none') + '] ' + (engine.displayName || '')
+    );
+  }
+}
+
+export async function enginesShow(id) {
+  if (!id) {
+    console.log('Usage: maestro engines show <id>');
+    return;
+  }
+  const described = await describeEngine(id);
+  if (!described.found) {
+    console.log('Engine "' + id + '" not found in ' + getEnginesFilePath() + '.');
+    return;
+  }
+  printJson(described.engineRecord);
+}
+
+export async function enginesHealth() {
+  const engines = await listEngineRecords();
+  for (const engine of engines) {
+    const health = engine.health || {};
+    console.log(
+      '- ' + engine.id + ': available=' + (health.available === null || health.available === undefined ? 'unknown' : health.available) +
+      ', recentSuccessRate=' + (typeof health.recentSuccessRate === 'number' ? Math.round(health.recentSuccessRate * 100) + '%' : 'unknown') +
+      ', consecutiveFailures=' + (health.consecutiveFailures || 0) +
+      ', lastCheckedAt=' + (health.lastCheckedAt || 'never')
+    );
+  }
+  const historySummary = await summarizeHistoryByEngine();
+  if (historySummary.length > 0) {
+    console.log('\nFrom .maestro/engine-history.jsonl:');
+    for (const entry of historySummary) {
+      console.log(
+        '- ' + entry.engine + ': runs=' + entry.totalRuns +
+        ', successRate=' + (entry.successRate === null ? 'unknown' : Math.round(entry.successRate * 100) + '%') +
+        ', lastRunAt=' + (entry.lastRunAt || 'never')
+      );
+    }
+  }
+}
+
+// Safe, limited validation: for engines with a real invocation module
+// (codex9, ai-router), call the engine's own non-mutating describe() (the
+// same contract `maestro doctor` already uses — it checks CLI/PATH
+// presence, it does NOT call a real model). Catalog-only entries with no
+// engineModule cannot be validated this way and are reported as such,
+// never silently marked validated.
+export async function enginesValidate(id) {
+  if (!id) {
+    console.log('Usage: maestro engines validate <id>');
+    return;
+  }
+  const record = await getEngineRecord(id);
+  if (!record) {
+    console.log('Engine "' + id + '" not found in ' + getEnginesFilePath() + '.');
+    return;
+  }
+  if (!record.runnable || !record.engineModule) {
+    console.log('Engine "' + id + '" has no invocation module in this repo (runnable=' + !!record.runnable + '). Cannot validate without building one first — see .maestro/V0_5_CURRENT_ARCHITECTURE_AUDIT.md.');
+    return;
+  }
+  try {
+    const engineModule = getEngine(id);
+    const description = await engineModule.describe();
+    console.log('Validation result for "' + id + '" (via engine.describe(), non-mutating, no real model call):');
+    printJson(description);
+  } catch (error) {
+    console.log('Could not validate "' + id + '": ' + error.message);
+  }
+}
+
+// Regenerates the redacted 9Router model inventory via a short, read-only
+// GET to /v1/models. Never calls /v1/chat/completions (would trigger a real,
+// possibly paid, model invocation). If 9Router isn't reachable, this reports
+// that clearly instead of failing the whole command or inventing data.
+export async function enginesResearch() {
+  const base = process.env.MAESTRO_NINEROUTER_BASE_URL || 'http://localhost:20128';
+  console.log('Probing ' + base + '/v1/models (read-only; no chat/completions call is made)...');
+  let response;
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    response = await fetch(base + '/v1/models', { signal: controller.signal });
+    clearTimeout(timeout);
+  } catch (error) {
+    console.log('9Router not reachable at ' + base + ' (' + error.message + '). Existing .maestro/NINEROUTER_*.md/json files were left unchanged.');
+    return;
+  }
+  if (!response.ok) {
+    console.log('9Router responded with HTTP ' + response.status + ' for /v1/models. Existing inventory files were left unchanged.');
+    return;
+  }
+  const data = await response.json();
+  const models = Array.isArray(data.data) ? data.data : [];
+  const byOwner = {};
+  for (const model of models) {
+    const owner = model.owned_by || 'unknown';
+    (byOwner[owner] = byOwner[owner] || []).push(model.id);
+  }
+  const inventoryPath = path.join(CONFIG.maestroPath, 'NINEROUTER_RAW_INVENTORY_REDACTED.json');
+  let existing = {};
+  try {
+    existing = JSON.parse(await fs.readFile(inventoryPath, 'utf-8'));
+  } catch (error) {
+    existing = {};
+  }
+  const updated = {
+    ...existing,
+    inspectedAt: new Date().toISOString(),
+    inspectionMethod: 'local-http-probe (maestro engines research)',
+    modelsByOwnerPrefix: byOwner,
+    modelCount: models.length
+  };
+  await fs.writeFile(inventoryPath, JSON.stringify(updated, null, 2) + '\n');
+  console.log('Refreshed ' + inventoryPath + ': ' + models.length + ' models across ' + Object.keys(byOwner).length + ' owner prefixes.');
+  console.log('This does not change .maestro/engines.json automatically — review new/changed models and update engine fiches manually, per project rule "não afirmar capacidade sem evidência".');
+}
+
+// ---- routing / preflight / dry-run --------------------------------------
+
+async function resolveTaskForCommand(id) {
+  if (id) {
+    const task = await getTaskById(id);
+    if (!task) {
+      console.log('Task #' + id + ' not found.');
+      return null;
+    }
+    return task;
+  }
+  const next = getNextTask(await getTasks());
+  if (!next) {
+    console.log('No task id given and no pending task found. Usage: maestro route-task <id>');
+    return null;
+  }
+  return next;
+}
+
+export async function routeTask(id) {
+  const task = await resolveTaskForCommand(id);
+  if (!task) return;
+  const classification = classifyTask(task);
+  const { selection, preflight } = await selectEngineWithPreflight(task, classification);
+  console.log('Task #' + task.id + ' "' + (task.title || task.description) + '"');
+  printJson({ classification, selection, preflight });
+}
+
+export async function preflightCommand(id) {
+  const task = await resolveTaskForCommand(id);
+  if (!task) return;
+  const classification = classifyTask(task);
+  const engines = await listEngineRecords();
+  const results = engines.map(engine => ({
+    engine: engine.id,
+    enabled: engine.enabled === true,
+    preflight: runPreflight(task, engine, classification),
+    policy: checkEnginePolicy(engine, { role: 'worker' })
+  }));
+  printJson({ taskId: task.id, classification, results });
+}
+
+export async function orchestraPlan(id, { dryRun = false } = {}) {
+  const task = await resolveTaskForCommand(id);
+  if (!task) return;
+  const classification = classifyTask(task);
+  const managerPlan = planSectorWork(task, classification);
+  const delegationPlan = buildDelegationPlan(task, classification, { depth: 0 });
+  const { selection, preflight } = await selectEngineWithPreflight(task, classification);
+  const budget = await loadBudget();
+  const budgetResult = await evaluateBudget({
+    engineRecord: selection.selectedEngine ? await getEngineRecord(selection.selectedEngine) : null
+  });
+  const fallbackGraph = await loadFallbackGraph();
+
+  const plan = {
+    mode: dryRun ? 'dry-run (no engine will be called)' : 'plan',
+    task: { id: task.id, title: task.title || task.description, status: task.status },
+    classification,
+    manager: managerPlan,
+    delegation: {
+      ...delegationPlan,
+      limits: DELEGATION_LIMITS
+    },
+    engineSelection: selection,
+    preflight,
+    budget: {
+      policy: budget,
+      evaluation: budgetResult
+    },
+    fallbackRulesAvailable: Object.keys(fallbackGraph.rules || {}),
+    verifier: {
+      required: classification.verificationRequired === true,
+      note: 'Deterministic checks (syntax/workspace-diff/tool-call detection) always run; a model-backed second opinion only runs if the caller opts in and budget allows it (src/orchestration/verifier.mjs).'
+    }
+  };
+
+  printJson(plan);
+  if (dryRun) {
+    console.log('\n(dry-run: no engine, worker, or model was actually called)');
+  }
+}
+
+// ---- budget ---------------------------------------------------------------
+
+export async function budgetCommand() {
+  const budget = await loadBudget();
+  printJson(budget);
+  console.log('\nEdit .maestro/budget.json directly to change policy (see .maestro/BUDGET_POLICY.md). There is no "maestro budget set" writer in v0.5.0.');
+}
+
+// ---- stats variants ---------------------------------------------------------
+
+export async function statsByEngine() {
+  const summary = await getUsageSummary();
+  console.log('Usage rows by engine (.maestro/usage.jsonl):');
+  printJson(summary.engines || {});
+  const history = await summarizeHistoryByEngine();
+  if (history.length > 0) {
+    console.log('\nOutcome history (.maestro/engine-history.jsonl):');
+    printJson(history);
+  }
+}
+
+export async function statsByRunKind() {
+  const summary = await getUsageSummary();
+  console.log('Usage rows by runKind (.maestro/usage.jsonl):');
+  printJson(summary.byRunKind || {});
+}
+
+export async function statsCost() {
+  const summary = await getUsageSummary();
+  console.log('ESTIMATED execution split by cost class (never real billing data):');
+  printJson(summary.executionByCost || {});
+  console.log('\nestimatedTotalTokens: ' + (summary.estimatedTotalTokens || 0));
+}
+
+export async function statsByGateDecision() {
+  const summary = await getUsageSummary();
+  console.log('Runtime gate decisions (.maestro/usage.jsonl, since v0.5.1):');
+  printJson(summary.byGateDecision || {});
+  console.log('\nBLOCK breakdown by cause (preflight / budget / policy / no-candidate):');
+  printJson(summary.byBlockReason || {});
+}

package/src/planner.mjs

@@ -0,0 +1,38 @@
+import path from 'path';
+import { CONFIG } from './config.mjs';
+import { addTask, archiveActiveTasksBeforePlan } from './tasks.mjs';
+import { writeTextWithBackup } from './files.mjs';
+import { buildSmartTasks } from './smart-planner.mjs';
+import { tryBuildSpecTasks } from './orchestration/spec-planner.mjs';
+
+const planFilePath = path.join(CONFIG.maestroPath, 'PLAN.md');
+
+export async function generatePlan(request, briefContent = '') {
+  let planContent = '# AI Maestro Plan\n\n';
+  planContent += '## Request\n' + request + '\n\n';
+
+  if (briefContent) {
+    planContent += '## Brief from .memory/BRIEF.md\n' + briefContent + '\n\n';
+  }
+
+  const specResult = await tryBuildSpecTasks(request);
+  const { kind, plannerKind, tasks: generatedTasks } = specResult.usedSpec ? specResult : buildSmartTasks(request);
+
+  planContent += '## Generated Tasks\n';
+  planContent += '(plannerKind: ' + plannerKind + ', requestKind: ' + kind + ')\n\n';
+
+  const archive = await archiveActiveTasksBeforePlan();
+  if (archive.archived.length > 0) {
+    planContent += 'Archived active tasks before replacing plan: ' + archive.archivePath + '\n\n';
+  }
+  for (const task of generatedTasks) {
+    const savedTask = await addTask(task.description, task);
+    planContent += '- [ ] #' + savedTask.id + ' ' + savedTask.title + ' [' + savedTask.engine + ', ' + savedTask.priority + ']\n';
+    for (const item of savedTask.acceptance) {
+      planContent += '  - Acceptance: ' + item + '\n';
+    }
+  }
+
+  await writeTextWithBackup(planFilePath, planContent);
+  return { planContent, archive, plannerKind, kind };
+}

package/src/project.mjs

@@ -0,0 +1 @@
+console.log('Project module');