@aria_asi/cli 0.2.39 → 0.2.41

package/scripts/export-owner-status-sheets.mjs

@@ -0,0 +1,589 @@
+#!/usr/bin/env node
+
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, join, resolve } from 'node:path';
+import { createHash } from 'node:crypto';
+
+const DEFAULT_TASK_DIR = join(homedir(), '.aria', 'cli-tasks');
+const DEFAULT_RUNTIME_STATE_DIR = join(homedir(), '.aria', 'runtime', 'state');
+const DEFAULT_OUT_DIR = join(homedir(), '.aria', 'owner-google-sheets');
+const DEFAULT_ACTION_LEDGER_DIR = join(homedir(), '.aria', 'action-ledger');
+
+function parseArgs(argv = process.argv.slice(2)) {
+  const args = {
+    taskDir: DEFAULT_TASK_DIR,
+    runtimeStateDir: DEFAULT_RUNTIME_STATE_DIR,
+    actionLedgerDir: DEFAULT_ACTION_LEDGER_DIR,
+    outDir: DEFAULT_OUT_DIR,
+    taskId: null,
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--task-dir') args.taskDir = resolve(argv[++index]);
+    else if (arg === '--runtime-state-dir') args.runtimeStateDir = resolve(argv[++index]);
+    else if (arg === '--action-ledger-dir') args.actionLedgerDir = resolve(argv[++index]);
+    else if (arg === '--out-dir') args.outDir = resolve(argv[++index]);
+    else if (arg === '--task-id') args.taskId = argv[++index];
+    else if (arg === '--help' || arg === '-h') {
+      printHelp();
+      process.exit(0);
+    }
+  }
+  return args;
+}
+
+function printHelp() {
+  console.log(`
+  node scripts/export-owner-status-sheets.mjs [options]
+
+  Exports Aria owner visibility tables for Google Sheets.
+
+  Options:
+    --task-id ID              Export a specific task. Defaults to latest active task.
+    --task-dir PATH           Defaults to ~/.aria/cli-tasks.
+    --runtime-state-dir PATH  Defaults to ~/.aria/runtime/state.
+    --action-ledger-dir PATH  Defaults to ~/.aria/action-ledger.
+    --out-dir PATH            Defaults to ~/.aria/owner-google-sheets.
+`);
+}
+
+function readJson(path, fallback = null) {
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function sha256Text(text) {
+  return createHash('sha256').update(text).digest('hex');
+}
+
+function sha256File(path) {
+  try {
+    return sha256Text(readFileSync(path, 'utf8'));
+  } catch {
+    return '';
+  }
+}
+
+function listTaskFiles(taskDir) {
+  if (!existsSync(taskDir)) return [];
+  return readdirSync(taskDir)
+    .filter((name) => name.endsWith('.json'))
+    .map((name) => join(taskDir, name))
+    .map((path) => {
+      const task = readJson(path);
+      return task && task.taskId ? { path, task } : null;
+    })
+    .filter(Boolean);
+}
+
+function taskTimestamp(task) {
+  return Date.parse(task.updatedAt || task.createdAt || 0) || 0;
+}
+
+function pickTask(taskFiles, taskId = null) {
+  if (taskId) return taskFiles.find((entry) => entry.task.taskId === taskId) || null;
+  const active = taskFiles
+    .filter((entry) => entry.task.status === 'active')
+    .sort((a, b) => taskTimestamp(b.task) - taskTimestamp(a.task));
+  if (active[0]) return active[0];
+  return taskFiles.sort((a, b) => taskTimestamp(b.task) - taskTimestamp(a.task))[0] || null;
+}
+
+function clean(value, max = 700) {
+  if (value === null || value === undefined) return '';
+  const text = typeof value === 'string' ? value : JSON.stringify(value);
+  return text.replace(/\s+/g, ' ').trim().slice(0, max);
+}
+
+function csvEscape(value) {
+  const text = clean(value, 5000);
+  if (/[",\n\r]/.test(text)) return `"${text.replace(/"/g, '""')}"`;
+  return text;
+}
+
+function toCsv(headers, rows) {
+  return [
+    headers.map(csvEscape).join(','),
+    ...rows.map((row) => headers.map((header) => csvEscape(row[header])).join(',')),
+  ].join('\n') + '\n';
+}
+
+function latestCheckpoint(task) {
+  const checkpoints = Array.isArray(task.checkpoints) ? task.checkpoints : [];
+  return checkpoints[checkpoints.length - 1] || {};
+}
+
+function allConsumerReceipts(task) {
+  const receipts = [];
+  for (const phase of Array.isArray(task.phases) ? task.phases : []) {
+    for (const receipt of Array.isArray(phase.consumerReceipts) ? phase.consumerReceipts : []) {
+      receipts.push({ phase, receipt });
+    }
+  }
+  return receipts;
+}
+
+function latestConsumerReceipt(task) {
+  return allConsumerReceipts(task)
+    .sort((a, b) => (Date.parse(b.receipt.at || 0) || 0) - (Date.parse(a.receipt.at || 0) || 0))[0] || null;
+}
+
+function currentPhase(task) {
+  const phases = Array.isArray(task.phases) ? task.phases : [];
+  return phases.find((phase) => ['active', 'in_progress', 'partial'].includes(phase.status))
+    || phases.find((phase) => phase.status === 'pending')
+    || {};
+}
+
+function qaCourt(runtimeStateDir) {
+  return readJson(join(runtimeStateDir, 'end-of-phase-qa-court-latest.json'), {});
+}
+
+function overviewRow(taskEntry, court) {
+  const { task, path } = taskEntry;
+  const phase = currentPhase(task);
+  const checkpoint = latestCheckpoint(task);
+  const receiptEntry = latestConsumerReceipt(task);
+  const forced = task.forcedSkillLoad || {};
+  const receipt = receiptEntry?.receipt || {};
+  return {
+    updated_at: new Date().toISOString(),
+    task_id: task.taskId,
+    status: task.status,
+    goal: task.goal,
+    current_phase: phase.phaseId || phase.title || '',
+    current_phase_status: phase.status || '',
+    last_checkpoint_at: checkpoint.at || '',
+    last_checkpoint: checkpoint.summary || '',
+    next_action: checkpoint.nextAction || receipt.correction?.action || '',
+    blockers: openBlockerCount(task),
+    qa_claim_verdict: court.claim_gate?.verdict || '',
+    qa_backend: court.backend_e2e?.status || '',
+    qa_user_facing: court.user_facing_e2e?.status || '',
+    qa_failure_modes: court.failure_modes?.status || '',
+    qa_qiyas: court.cognitive_qiyas_15?.status || '',
+    qa_tadabbur: court.cognitive_tadabbur_12?.status || '',
+    skills: `${forced.firedSkillCount || forced.loadedCount || ''}/${forced.floors?.skill || ''}`,
+    runtimes: `${forced.activeRuntimeCount || ''}/${forced.floors?.runtime || ''}`,
+    primitives: `${forced.activePrimitiveCount || ''}/${forced.floors?.primitive || ''}`,
+    mappings: `${forced.activeMappingCount || ''}/${forced.floors?.mapping || ''}`,
+    source_file: path,
+    source_sha256: sha256File(path),
+  };
+}
+
+function phaseRows(taskEntry) {
+  const { task, path } = taskEntry;
+  return (Array.isArray(task.phases) ? task.phases : []).map((phase) => {
+    const latest = (phase.consumerReceipts || []).slice(-1)[0] || {};
+    return {
+      task_id: task.taskId,
+      phase_id: phase.phaseId || '',
+      title: phase.title || '',
+      status: phase.status || '',
+      attempts: phase.attempts ?? '',
+      started_at: phase.startedAt || '',
+      completed_at: phase.completedAt || '',
+      last_receipt_at: latest.at || '',
+      last_receipt_boundary: latest.boundary || '',
+      last_summary: latest.summary || '',
+      last_decision: latest.decision || '',
+      correction_gaps: (latest.correction?.gaps || []).join('; '),
+      next_action: latest.correction?.action || '',
+      source_file: path,
+    };
+  });
+}
+
+function eventRows(taskEntry) {
+  const { task, path } = taskEntry;
+  const checkpointRows = (Array.isArray(task.checkpoints) ? task.checkpoints : []).map((checkpoint) => ({
+    at: checkpoint.at || '',
+    task_id: task.taskId,
+    phase_id: checkpoint.phaseId || checkpoint.phase || '',
+    event_type: 'checkpoint',
+    status: checkpoint.status || '',
+    summary: checkpoint.summary || '',
+    evidence: checkpoint.evidence || '',
+    next_action: checkpoint.nextAction || '',
+    source_file: path,
+  }));
+  const receiptRows = allConsumerReceipts(task).map(({ phase, receipt }) => ({
+    at: receipt.at || '',
+    task_id: task.taskId,
+    phase_id: phase.phaseId || receipt.phaseId || '',
+    event_type: receipt.boundary || 'receipt',
+    status: receipt.status || '',
+    summary: receipt.summary || '',
+    evidence: receipt.evidence || '',
+    next_action: receipt.correction?.action || '',
+    source_file: path,
+  }));
+  return [...checkpointRows, ...receiptRows].sort((a, b) => (Date.parse(a.at || 0) || 0) - (Date.parse(b.at || 0) || 0));
+}
+
+function receiptRows(taskEntry, court) {
+  const { task } = taskEntry;
+  const forced = task.forcedSkillLoad || {};
+  const latestReceipt = latestConsumerReceipt(task)?.receipt || {};
+  return [
+    {
+      receipt_type: 'forced_skill_load',
+      at: task.updatedAt || '',
+      task_id: task.taskId,
+      ok: forced.ok,
+      mode: forced.skillExecutionMode,
+      skills: forced.firedSkillCount || forced.loadedCount || '',
+      runtimes: forced.activeRuntimeCount || '',
+      primitives: forced.activePrimitiveCount || '',
+      mappings: forced.activeMappingCount || '',
+      qa_skills: forced.qaSkillCount || '',
+      correction_skills: forced.correctionSkillCount || '',
+      qiyas: forced.cognitiveRuntimeReceipts?.qiyas?.perspectiveCount || '',
+      tadabbur: forced.cognitiveRuntimeReceipts?.tadabbur?.stageCount || '',
+      noor: forced.cognitiveRuntimeReceipts?.noor?.noorSuiteCount || '',
+      verdict: forced.cognitiveRuntimeReceipts?.mizan?.verdict || '',
+      hash: forced.skillExecutionReceipt?.receiptHash || '',
+    },
+    {
+      receipt_type: 'latest_phase_consumer',
+      at: latestReceipt.at || '',
+      task_id: task.taskId,
+      ok: latestReceipt.mechanicalReceipt?.ok,
+      mode: latestReceipt.skillExecutionMode,
+      skills: latestReceipt.mechanicalReceipt?.firedSkillCount || '',
+      runtimes: latestReceipt.observed?.activeRuntimeCount || '',
+      primitives: latestReceipt.observed?.activePrimitiveCount || '',
+      mappings: latestReceipt.observed?.activeMappingCount || '',
+      qa_skills: latestReceipt.observed?.qaSkillCount || '',
+      correction_skills: latestReceipt.observed?.correctionSkillCount || '',
+      qiyas: latestReceipt.cognitiveRuntimeReceipts?.qiyasPerspectiveCount || '',
+      tadabbur: latestReceipt.cognitiveRuntimeReceipts?.tadabburStageCount || '',
+      noor: latestReceipt.cognitiveRuntimeReceipts?.noorSuiteCount || '',
+      verdict: latestReceipt.decision || '',
+      hash: latestReceipt.receiptHash || '',
+    },
+    {
+      receipt_type: 'latest_qa_court',
+      at: court.generated_at || '',
+      task_id: task.taskId,
+      ok: court.claim_gate?.verdict || '',
+      mode: court.autofire?.mode || '',
+      skills: '',
+      runtimes: '',
+      primitives: '',
+      mappings: '',
+      qa_skills: '',
+      correction_skills: '',
+      qiyas: court.cognitive_qiyas_15?.perspectives || '',
+      tadabbur: court.cognitive_tadabbur_12?.stages || '',
+      noor: '',
+      verdict: court.claim_gate?.verdict || '',
+      hash: sha256Text(JSON.stringify(court)),
+    },
+  ];
+}
+
+function blockerRows(taskEntry) {
+  const { task, path } = taskEntry;
+  const rows = [];
+  for (const phase of Array.isArray(task.phases) ? task.phases : []) {
+    if (['blocked', 'failed', 'partial'].includes(phase.status)) {
+      rows.push({
+        task_id: task.taskId,
+        phase_id: phase.phaseId || '',
+        status: phase.status,
+        blocker: phase.recovery?.reason || 'phase is not fully complete',
+        action: '',
+        evidence: '',
+        source_file: path,
+      });
+    }
+    for (const receipt of Array.isArray(phase.consumerReceipts) ? phase.consumerReceipts : []) {
+      for (const gap of receipt.correction?.gaps || []) {
+        rows.push({
+          task_id: task.taskId,
+          phase_id: phase.phaseId || receipt.phaseId || '',
+          status: receipt.status || phase.status || '',
+          blocker: gap,
+          action: receipt.correction?.action || '',
+          evidence: receipt.evidence || '',
+          source_file: path,
+        });
+      }
+    }
+  }
+  return rows;
+}
+
+function openBlockerCount(task) {
+  return blockerRows({ task, path: '' }).length;
+}
+
+function readJsonl(path) {
+  if (!existsSync(path)) return [];
+  return readFileSync(path, 'utf8')
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      try { return JSON.parse(line); } catch { return null; }
+    })
+    .filter(Boolean);
+}
+
+function listActionLedgerProjects(actionLedgerDir) {
+  if (!existsSync(actionLedgerDir)) return [];
+  return readdirSync(actionLedgerDir, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => {
+      const projectId = entry.name;
+      const root = join(actionLedgerDir, projectId);
+      const projectionPath = join(root, 'projection.json');
+      const eventsPath = join(root, 'events.jsonl');
+      const publishOutboxPath = join(root, 'publish-outbox.jsonl');
+      return {
+        projectId,
+        root,
+        projectionPath,
+        eventsPath,
+        publishOutboxPath,
+        projection: readJson(projectionPath, null),
+        events: readJsonl(eventsPath),
+        publishOutbox: readJsonl(publishOutboxPath),
+      };
+    });
+}
+
+function actionLedgerRows(actionLedgerDir) {
+  return listActionLedgerProjects(actionLedgerDir).map((project) => {
+    const projection = project.projection || {};
+    const latest = projection.latestEvent || {};
+    const latestEvent = project.events.find((event) => event.eventId === latest.eventId) || {};
+    const taskIds = Object.keys(projection.tasks || {});
+    const sessionIds = Object.keys(projection.sessions || {});
+    const compiledWorkUnits = projection.compiledWorkUnits || {};
+    const compiledRefs = Object.values(compiledWorkUnits);
+    const latestCompiled = compiledRefs[compiledRefs.length - 1] || {};
+    return {
+      project_id: project.projectId,
+      event_count: projection.eventCount ?? project.events.length,
+      task_count: taskIds.length,
+      session_count: sessionIds.length,
+      compiled_work_unit_count: compiledRefs.length,
+      latest_compiled_work_unit_id: latestCompiled.workUnitId || '',
+      latest_compiled_work_unit_status: latestCompiled.status || '',
+      latest_compiled_work_unit_authority_cap: latestCompiled.authorityCap ?? '',
+      latest_event_id: latest.eventId || '',
+      latest_surface: latest.surface || latestEvent.surface || '',
+      latest_phase: latest.lifecyclePhase || latestEvent.lifecyclePhase || '',
+      latest_status: latest.status || latestEvent.status || '',
+      latest_created_at: latest.createdAt || latestEvent.createdAt || '',
+      correction_required: projection.correctionRequired ?? '',
+      latest_qa: projection.latestQa || '',
+      latest_atlas_status: projection.latestAtlas?.status || '',
+      latest_atlas_target: projection.latestAtlas?.target || '',
+      sentinel_findings: Array.isArray(projection.sentinelFindings) ? projection.sentinelFindings.length : '',
+      publish_outbox_count: project.publishOutbox.length,
+      events_path: project.eventsPath,
+      projection_path: project.projectionPath,
+      publish_outbox_path: project.publishOutboxPath,
+    };
+  }).sort((a, b) => String(b.latest_created_at || '').localeCompare(String(a.latest_created_at || '')));
+}
+
+function actionLedgerPublishQueueRows(actionLedgerDir) {
+  return listActionLedgerProjects(actionLedgerDir)
+    .flatMap((project) => project.publishOutbox.map((entry) => ({
+      project_id: project.projectId,
+      at: entry.at || '',
+      event_id: entry.eventId || entry.event?.eventId || '',
+      action_id: entry.actionId || entry.event?.actionId || '',
+      surface: entry.event?.surface || '',
+      task_id: entry.taskId || entry.event?.taskId || '',
+      phase_id: entry.phaseId || entry.event?.phaseId || '',
+      lifecycle_phase: entry.event?.lifecyclePhase || '',
+      status: entry.event?.status || '',
+      replay_attempts: entry.replayAttempts || '',
+      last_replay_at: entry.lastReplayAt || '',
+      error: entry.lastReplayError || entry.error || '',
+      recovery: entry.recovery || '',
+      publish_outbox_path: project.publishOutboxPath,
+    })))
+    .sort((a, b) => String(b.at || '').localeCompare(String(a.at || '')));
+}
+
+function writeTable(outDir, name, headers, rows) {
+  const csv = toCsv(headers, rows);
+  const path = join(outDir, `${name}.csv`);
+  writeFileSync(path, csv);
+  return { name, path, rows: rows.length, sha256: sha256Text(csv) };
+}
+
+export function exportOwnerGoogleSheetsCsv(options = {}) {
+  const taskDir = resolve(options.taskDir || DEFAULT_TASK_DIR);
+  const runtimeStateDir = resolve(options.runtimeStateDir || DEFAULT_RUNTIME_STATE_DIR);
+  const actionLedgerDir = resolve(options.actionLedgerDir || DEFAULT_ACTION_LEDGER_DIR);
+  const outDir = resolve(options.outDir || DEFAULT_OUT_DIR);
+  mkdirSync(outDir, { recursive: true });
+
+  const taskFiles = listTaskFiles(taskDir);
+  const taskEntry = pickTask(taskFiles, options.taskId || null);
+  if (!taskEntry) {
+    throw new Error(`No Aria task JSON files found in ${taskDir}`);
+  }
+
+  const court = qaCourt(runtimeStateDir);
+  const tables = [
+    writeTable(outDir, 'Overview', [
+      'updated_at',
+      'task_id',
+      'status',
+      'goal',
+      'current_phase',
+      'current_phase_status',
+      'last_checkpoint_at',
+      'last_checkpoint',
+      'next_action',
+      'blockers',
+      'qa_claim_verdict',
+      'qa_backend',
+      'qa_user_facing',
+      'qa_failure_modes',
+      'qa_qiyas',
+      'qa_tadabbur',
+      'skills',
+      'runtimes',
+      'primitives',
+      'mappings',
+      'source_file',
+      'source_sha256',
+    ], [overviewRow(taskEntry, court)]),
+    writeTable(outDir, 'Phases', [
+      'task_id',
+      'phase_id',
+      'title',
+      'status',
+      'attempts',
+      'started_at',
+      'completed_at',
+      'last_receipt_at',
+      'last_receipt_boundary',
+      'last_summary',
+      'last_decision',
+      'correction_gaps',
+      'next_action',
+      'source_file',
+    ], phaseRows(taskEntry)),
+    writeTable(outDir, 'Events', [
+      'at',
+      'task_id',
+      'phase_id',
+      'event_type',
+      'status',
+      'summary',
+      'evidence',
+      'next_action',
+      'source_file',
+    ], eventRows(taskEntry)),
+    writeTable(outDir, 'Receipts', [
+      'receipt_type',
+      'at',
+      'task_id',
+      'ok',
+      'mode',
+      'skills',
+      'runtimes',
+      'primitives',
+      'mappings',
+      'qa_skills',
+      'correction_skills',
+      'qiyas',
+      'tadabbur',
+      'noor',
+      'verdict',
+      'hash',
+    ], receiptRows(taskEntry, court)),
+    writeTable(outDir, 'Blockers', [
+      'task_id',
+      'phase_id',
+      'status',
+      'blocker',
+      'action',
+      'evidence',
+      'source_file',
+    ], blockerRows(taskEntry)),
+    writeTable(outDir, 'ActionLedger', [
+      'project_id',
+      'event_count',
+      'task_count',
+      'session_count',
+      'compiled_work_unit_count',
+      'latest_compiled_work_unit_id',
+      'latest_compiled_work_unit_status',
+      'latest_compiled_work_unit_authority_cap',
+      'latest_event_id',
+      'latest_surface',
+      'latest_phase',
+      'latest_status',
+      'latest_created_at',
+      'correction_required',
+      'latest_qa',
+      'latest_atlas_status',
+      'latest_atlas_target',
+      'sentinel_findings',
+      'publish_outbox_count',
+      'events_path',
+      'projection_path',
+      'publish_outbox_path',
+    ], actionLedgerRows(actionLedgerDir)),
+    writeTable(outDir, 'ActionLedgerPublishQueue', [
+      'project_id',
+      'at',
+      'event_id',
+      'action_id',
+      'surface',
+      'task_id',
+      'phase_id',
+      'lifecycle_phase',
+      'status',
+      'replay_attempts',
+      'last_replay_at',
+      'error',
+      'recovery',
+      'publish_outbox_path',
+    ], actionLedgerPublishQueueRows(actionLedgerDir)),
+  ];
+
+  const manifest = {
+    ok: true,
+    schema: 'aria.owner_google_sheets_export.v1',
+    generatedAt: new Date().toISOString(),
+    taskId: taskEntry.task.taskId,
+    taskStatus: taskEntry.task.status,
+    taskFile: taskEntry.path,
+    actionLedgerDir,
+    outDir,
+    tables,
+  };
+  writeFileSync(join(outDir, 'manifest.json'), JSON.stringify(manifest, null, 2) + '\n');
+  writeFileSync(join(outDir, 'latest.json'), JSON.stringify({
+    ...manifest,
+    overview: overviewRow(taskEntry, court),
+  }, null, 2) + '\n');
+  return manifest;
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  try {
+    const manifest = exportOwnerGoogleSheetsCsv(parseArgs());
+    console.log(JSON.stringify(manifest, null, 2));
+  } catch (error) {
+    console.error(error && error.message ? error.message : String(error));
+    process.exit(1);
+  }
+}