@jaimevalasek/aioson 1.7.0 → 1.8.0

package/src/commands/locale-diff.js

@@ -1,125 +1,24 @@
 'use strict';
 
-const fs = require('node:fs/promises');
-const path = require('node:path');
-const { TEMPLATE_DIR } = require('../installer');
-
-const AGENTS = ['setup', 'analyst', 'architect', 'pm', 'ux-ui', 'dev', 'qa', 'orchestrator'];
-const LOCALES = ['en', 'pt-BR', 'es', 'fr'];
-
-// Extract ## Section headings from markdown content
-function extractSections(content) {
-  const sections = [];
-  for (const line of content.split('\n')) {
-    if (/^#{1,3} /.test(line)) {
-      sections.push(line.trim());
-    }
-  }
-  return sections;
-}
-
-// Normalize a heading to a comparable key (remove locale-specific punctuation/accents)
-function normalizeHeading(heading) {
-  return heading
-    .toLowerCase()
-    .replace(/[áàâãä]/g, 'a')
-    .replace(/[éèêë]/g, 'e')
-    .replace(/[íìîï]/g, 'i')
-    .replace(/[óòôõö]/g, 'o')
-    .replace(/[úùûü]/g, 'u')
-    .replace(/[ç]/g, 'c')
-    .replace(/[ñ]/g, 'n')
-    .replace(/[^a-z0-9# ]/g, '')
-    .replace(/\s+/g, ' ')
-    .trim();
-}
-
-async function readFile(filePath) {
-  try {
-    return await fs.readFile(filePath, 'utf8');
-  } catch {
-    return null;
-  }
-}
-
 async function runLocaleDiff({ args, options, logger }) {
   const jsonMode = Boolean(options.json);
   const log = jsonMode ? () => {} : logger.log.bind(logger);
-
-  const filterAgent = args[0] || null; // optional: check only one agent
-  const filterLocale = options.lang || options.language || null;
-
-  const baseAgentsDir = path.join(TEMPLATE_DIR, '.aioson', 'agents');
-  const localesDir    = path.join(TEMPLATE_DIR, '.aioson', 'locales');
-
-  const agentsToCheck = filterAgent
-    ? AGENTS.filter(a => a === filterAgent)
-    : AGENTS;
-  const localesToCheck = filterLocale
-    ? LOCALES.filter(l => l === filterLocale)
-    : LOCALES;
-
-  const report = [];
-  let totalMissing = 0;
-
-  for (const agent of agentsToCheck) {
-    const baseFile = path.join(baseAgentsDir, `${agent}.md`);
-    const baseContent = await readFile(baseFile);
-    if (!baseContent) {
-      log(`WARN: base agent @${agent} not found`);
-      continue;
-    }
-
-    const baseSections = extractSections(baseContent);
-    const baseNorm = baseSections.map(s => ({ original: s, key: normalizeHeading(s) }));
-
-    for (const locale of localesToCheck) {
-      const localeFile = path.join(localesDir, locale, 'agents', `${agent}.md`);
-      const localeContent = await readFile(localeFile);
-      if (!localeContent) {
-        log(`WARN: @${agent} (${locale}) not found`);
-        continue;
-      }
-
-      const localeSections = extractSections(localeContent);
-      const localeNormSet = new Set(localeSections.map(s => normalizeHeading(s)));
-
-      const missing = baseNorm.filter(({ key }) => !localeNormSet.has(key));
-
-      if (missing.length > 0) {
-        totalMissing += missing.length;
-        const entry = {
-          agent,
-          locale,
-          missingSections: missing.map(m => m.original)
-        };
-        report.push(entry);
-        if (!jsonMode) {
-          log(`@${agent} (${locale}) — ${missing.length} section(s) missing in locale:`);
-          for (const m of missing) {
-            log(`  - ${m.original}`);
-          }
-        }
-      }
-    }
-  }
+  const requestedAgent = args[0] || null;
+  const requestedLanguage = options.lang || options.language || null;
 
   if (!jsonMode) {
-    log('');
-    if (totalMissing === 0) {
-      log('No drift detected — all locale files contain equivalent sections to base.');
-    } else {
-      log(`${totalMissing} section(s) present in base but missing in locale files.`);
-      log('These may be intentional simplifications or unintentional drift.');
-    }
+    log('Agent locale packs are no longer shipped.');
+    log('Canonical agent prompts now live only in `.aioson/agents/` and user-facing language is controlled by `interaction_language`.');
   }
 
   return {
-    ok: totalMissing === 0,
-    totalMissing,
-    agents: agentsToCheck,
-    locales: localesToCheck,
-    drifts: report
+    ok: true,
+    deprecated: true,
+    mode: 'canonical-english-only',
+    agent: requestedAgent,
+    language: requestedLanguage,
+    totalMissing: 0,
+    drifts: []
   };
 }
 

package/src/commands/mcp-doctor.js

@@ -2,7 +2,7 @@
 
 const fs = require('node:fs/promises');
 const path = require('node:path');
-const { validateProjectContextFile } = require('../context');
+const { validateProjectContextFile, getInteractionLanguage } = require('../context');
 const { localizeContextParseReason } = require('../context-parse-reason');
 const { exists, readTextIfExists } = require('../utils');
 const { extractStackValue, normalizeDatabaseEngine } = require('./mcp-init');
@@ -354,6 +354,7 @@ async function runMcpDoctor({ args, options = {}, logger, t }) {
       filePath: contextPath,
       projectType: String(contextData.project_type || ''),
       framework: String(contextData.framework || ''),
+      interactionLanguage: getInteractionLanguage(contextData, 'en'),
       conversationLanguage: String(contextData.conversation_language || '')
     },
     plan: {

package/src/commands/mcp-init.js

@@ -2,7 +2,7 @@
 
 const fs = require('node:fs/promises');
 const path = require('node:path');
-const { validateProjectContextFile } = require('../context');
+const { validateProjectContextFile, getInteractionLanguage } = require('../context');
 const { createTranslator } = require('../i18n');
 const { ensureDir, readTextIfExists } = require('../utils');
 
@@ -151,14 +151,7 @@ function buildMcpPlan(targetDir, contextData, contextMarkdown, t) {
       reason: translate('mcp_init.reason_web_search'),
       env: []
     },
-    buildChainRpcServer(web3Enabled, networks, t),
-    {
-      id: 'makopy',
-      enabled: false,
-      recommended: false,
-      reason: translate('mcp_init.reason_makopy'),
-      env: ['MAKOPY_API_KEY']
-    }
+    buildChainRpcServer(web3Enabled, networks, t)
   ];
 
   return {
@@ -167,7 +160,8 @@ function buildMcpPlan(targetDir, contextData, contextMarkdown, t) {
       path: targetDir,
       framework: contextData.framework || '',
       project_type: contextData.project_type || '',
-      conversation_language: contextData.conversation_language || 'en'
+      interaction_language: getInteractionLanguage(contextData, 'en'),
+      conversation_language: getInteractionLanguage(contextData, 'en')
     },
     database_engine: databaseEngine,
     web3_enabled: web3Enabled,

package/src/commands/memory.js

@@ -0,0 +1,234 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { openRuntimeDb } = require('../runtime-store');
+
+const REQUIRED_BOOTSTRAP = ['what-is.md', 'what-it-does.md', 'how-it-works.md', 'current-state.md'];
+
+async function fileExists(filePath) {
+  try {
+    const stat = await fs.stat(filePath);
+    return stat.isFile();
+  } catch {
+    return false;
+  }
+}
+
+async function readText(filePath) {
+  try {
+    return await fs.readFile(filePath, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+async function listFiles(dirPath, predicate = () => true) {
+  try {
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    return entries
+      .filter((entry) => entry.isFile() && predicate(entry.name))
+      .map((entry) => entry.name)
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+function firstLine(text) {
+  const withoutFrontmatter = String(text || '').replace(/^---[\s\S]*?---\r?\n?/, '');
+  return withoutFrontmatter
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .find((line) => line && !line.startsWith('#')) || '';
+}
+
+async function collectRuntimeSummary(targetDir) {
+  let handle;
+  try {
+    handle = await openRuntimeDb(targetDir, { mustExist: true });
+  } catch {
+    return { exists: false, taskCounts: {}, recentRuns: [], learnings: 0 };
+  }
+
+  if (!handle || !handle.db) {
+    return { exists: false, taskCounts: {}, recentRuns: [], learnings: 0 };
+  }
+
+  const { db, dbPath } = handle;
+  try {
+    const rows = db.prepare('SELECT status, COUNT(*) AS count FROM tasks GROUP BY status').all();
+    const taskCounts = {};
+    for (const row of rows) taskCounts[row.status] = Number(row.count || 0);
+
+    const recentRuns = db.prepare(`
+      SELECT agent_name, status, summary, title, finished_at, updated_at
+      FROM agent_runs
+      ORDER BY COALESCE(finished_at, updated_at, started_at) DESC
+      LIMIT 8
+    `).all();
+
+    let learnings = 0;
+    try {
+      const row = db.prepare("SELECT COUNT(*) AS count FROM project_learnings WHERE status = 'active'").get();
+      learnings = Number(row?.count || 0);
+    } catch {
+      learnings = 0;
+    }
+
+    return { exists: true, dbPath, taskCounts, recentRuns, learnings };
+  } finally {
+    db.close();
+  }
+}
+
+async function collectMemoryStatus(targetDir) {
+  const bootstrapDir = path.join(targetDir, '.aioson', 'context', 'bootstrap');
+  const bootstrapFiles = [];
+  for (const name of REQUIRED_BOOTSTRAP) {
+    bootstrapFiles.push({
+      path: `.aioson/context/bootstrap/${name}`,
+      exists: await fileExists(path.join(bootstrapDir, name))
+    });
+  }
+
+  const memoryIndexPath = path.join(targetDir, '.aioson', 'context', 'memory-index.md');
+  const contextPackPath = path.join(targetDir, '.aioson', 'context', 'context-pack.md');
+  const projectPulsePath = path.join(targetDir, '.aioson', 'context', 'project-pulse.md');
+  const logsDir = path.join(targetDir, 'aioson-logs');
+  const devlogs = await listFiles(logsDir, (name) => name.startsWith('devlog-') && name.endsWith('.md'));
+  const devlogManifestPath = path.join(logsDir, 'manifest.md');
+
+  const brainsDir = path.join(targetDir, '.aioson', 'brains');
+  const brainIndexPath = path.join(brainsDir, '_index.json');
+  let brainIndex = null;
+  const brainWarnings = [];
+  try {
+    brainIndex = JSON.parse(await fs.readFile(brainIndexPath, 'utf8'));
+  } catch {
+    brainWarnings.push(`Missing or invalid ${path.relative(targetDir, brainIndexPath)}`);
+  }
+
+  const brains = Array.isArray(brainIndex?.brains) ? brainIndex.brains : [];
+  for (const brain of brains) {
+    const rel = String(brain.path || '');
+    const brainPath = rel.startsWith('.aioson/brains/')
+      ? path.join(targetDir, rel)
+      : path.join(brainsDir, rel);
+    if (!(await fileExists(brainPath))) {
+      brainWarnings.push(`Missing brain file: ${rel || brain.id || '(unknown)'}`);
+    }
+  }
+
+  const runtime = await collectRuntimeSummary(targetDir);
+  const bootstrapCoverage = bootstrapFiles.filter((file) => file.exists).length;
+
+  return {
+    ok: bootstrapCoverage === REQUIRED_BOOTSTRAP.length && brainWarnings.length === 0,
+    targetDir,
+    bootstrap: {
+      required: REQUIRED_BOOTSTRAP.length,
+      present: bootstrapCoverage,
+      missing: bootstrapFiles.filter((file) => !file.exists).map((file) => file.path),
+      files: bootstrapFiles
+    },
+    context: {
+      memoryIndex: await fileExists(memoryIndexPath),
+      contextPack: await fileExists(contextPackPath),
+      projectPulse: await fileExists(projectPulsePath)
+    },
+    devlogs: {
+      count: devlogs.length,
+      manifest: await fileExists(devlogManifestPath),
+      files: devlogs.map((name) => `aioson-logs/${name}`)
+    },
+    brains: {
+      index: await fileExists(brainIndexPath),
+      count: brains.length,
+      files: brains.map((brain) => brain.path).filter(Boolean),
+      warnings: brainWarnings
+    },
+    runtime
+  };
+}
+
+function formatTaskCounts(counts) {
+  const entries = Object.entries(counts || {});
+  if (entries.length === 0) return 'none';
+  return entries.map(([key, value]) => `${key}:${value}`).join(', ');
+}
+
+async function runMemoryStatus({ args, options = {}, logger }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const status = await collectMemoryStatus(targetDir);
+
+  if (options.json) return status;
+
+  logger.log('AIOSON Memory Status');
+  logger.log(`Bootstrap: ${status.bootstrap.present}/${status.bootstrap.required}`);
+  if (status.bootstrap.missing.length > 0) {
+    logger.log(`Missing bootstrap: ${status.bootstrap.missing.join(', ')}`);
+  }
+  logger.log(`Memory index: ${status.context.memoryIndex ? 'present' : 'missing'}`);
+  logger.log(`Context pack: ${status.context.contextPack ? 'present' : 'missing'}`);
+  logger.log(`Project pulse: ${status.context.projectPulse ? 'present' : 'missing'}`);
+  logger.log(`Devlogs: ${status.devlogs.count} (${status.devlogs.manifest ? 'manifest present' : 'no manifest'})`);
+  logger.log(`Brains: ${status.brains.count} indexed${status.brains.warnings.length ? `, ${status.brains.warnings.length} warning(s)` : ''}`);
+  for (const warning of status.brains.warnings) logger.log(`- ${warning}`);
+  logger.log(`Runtime: ${status.runtime.exists ? formatTaskCounts(status.runtime.taskCounts) : 'missing'}`);
+  logger.log(`Active learnings: ${status.runtime.learnings || 0}`);
+  return status;
+}
+
+async function runMemorySummary({ args, options = {}, logger }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const status = await collectMemoryStatus(targetDir);
+  const pulse = await readText(path.join(targetDir, '.aioson', 'context', 'project-pulse.md'));
+  const whatIs = await readText(path.join(targetDir, '.aioson', 'context', 'bootstrap', 'what-is.md'));
+  const currentState = await readText(path.join(targetDir, '.aioson', 'context', 'bootstrap', 'current-state.md'));
+
+  const recentRuns = (status.runtime.recentRuns || []).slice(0, Number(options.last || 5));
+  const lines = [
+    '# AIOSON Memory Summary',
+    '',
+    '## Bootstrap',
+    `- Coverage: ${status.bootstrap.present}/${status.bootstrap.required}`,
+    `- Identity: ${firstLine(whatIs) || 'not available'}`,
+    `- Current state: ${firstLine(currentState) || 'not available'}`,
+    '',
+    '## Project Pulse',
+    pulse ? pulse.split(/\r?\n/).slice(0, 28).join('\n') : '_No project-pulse.md found_',
+    '',
+    '## Recent Runtime',
+    status.runtime.exists
+      ? `- Tasks: ${formatTaskCounts(status.runtime.taskCounts)}`
+      : '- Runtime database missing',
+    `- Active learnings: ${status.runtime.learnings || 0}`
+  ];
+
+  if (recentRuns.length > 0) {
+    lines.push('', '## Recent Runs');
+    for (const run of recentRuns) {
+      const when = run.finished_at || run.updated_at || '';
+      const summary = run.summary || run.title || '(no summary)';
+      lines.push(`- ${when} ${run.agent_name}: ${summary}`);
+    }
+  }
+
+  lines.push('', '## Retrieval Hints');
+  lines.push('- Use `aioson context:pack . --agent=<agent> --goal="<task>"` for focused project context.');
+  lines.push('- Use `aioson brain:query . --tags=<tags> --min-quality=4` for procedural patterns.');
+  lines.push('- Use Git only when memory and runtime do not explain recent work.');
+
+  const summary = lines.join('\n');
+  if (options.json) return { ok: true, status, summary };
+  logger.log(summary);
+  return { ok: true, status, summary };
+}
+
+module.exports = {
+  REQUIRED_BOOTSTRAP,
+  collectMemoryStatus,
+  runMemoryStatus,
+  runMemorySummary
+};

package/src/commands/parallel-assign.js

@@ -6,6 +6,20 @@ const { validateProjectContextFile } = require('../context');
 const { exists, toRelativeSafe } = require('../utils');
 const { parseWorkers, normalizeClassification } = require('./parallel-init');
 const { recordRuntimeOperation } = require('../execution-gateway');
+const {
+  WORKSPACE_MANIFEST_RELATIVE_PATH,
+  OWNERSHIP_MAP_RELATIVE_PATH,
+  MERGE_PLAN_RELATIVE_PATH,
+  buildLaneOwnershipEntries,
+  buildWorkspaceManifest,
+  buildOwnershipMap,
+  buildMergePlan,
+  extractStatusDependencyItems,
+  extractStatusWritePathItems,
+  extractStatusMergeRank,
+  replaceSection,
+  replaceMetadataLine
+} = require('../parallel-workspace');
 
 const SOURCE_ALIAS = {
   prd: '.aioson/context/prd.md',
@@ -164,30 +178,11 @@ function distributeScopes(scopes, workers) {
 }
 
 function replaceScopeSection(content, items) {
-  const text = String(content || '');
-  const lines = text.split(/\r?\n/);
-  const start = lines.findIndex((line) => line.trim() === '## Scope');
-  const scopeLines = items.length > 0 ? items.map((item) => `- ${item}`) : ['- [unassigned]'];
-
-  if (start === -1) {
-    const suffix = lines.length > 0 && lines[lines.length - 1] === '' ? '' : '\n';
-    return `${text}${suffix}\n## Scope\n${scopeLines.join('\n')}\n`;
-  }
-
-  let end = lines.length;
-  for (let i = start + 1; i < lines.length; i += 1) {
-    if (lines[i].startsWith('## ')) {
-      end = i;
-      break;
-    }
-  }
-
-  const replaced = [
-    ...lines.slice(0, start + 1),
-    ...scopeLines,
-    ...lines.slice(end)
-  ];
-  return `${replaced.join('\n').replace(/\n*$/, '\n')}`;
+  return replaceSection(
+    content,
+    'Scope',
+    items.length > 0 ? items.map((item) => `- ${item}`) : ['- [unassigned]']
+  );
 }
 
 function updateTimestamp(content, generatedAt) {
@@ -198,6 +193,13 @@ function updateTimestamp(content, generatedAt) {
   return text;
 }
 
+function extractMetadata(content, key, fallback = '') {
+  const regex = new RegExp(`^-\\s*${key}:\\s*(.*)$`, 'im');
+  const match = String(content || '').match(regex);
+  if (!match) return fallback;
+  return String(match[1] || '').trim() || fallback;
+}
+
 function appendSharedDecision(content, generatedAt, sourcePath, workers, scopeCount) {
   const row =
     `| ${generatedAt} | Scope assignment initialized | ` +
@@ -290,19 +292,90 @@ async function runParallelAssign({ args, options = {}, logger, t }) {
   const assignments = distributeScopes(extracted.scopes, workers);
   const generatedAt = new Date().toISOString();
   const filesUpdated = [];
+  const projectName =
+    String((context.data && context.data.project_name) || '').trim() || path.basename(targetDir) || 'project';
+  const laneStatusByIndex = new Map();
+  const enrichedAssignments = [];
 
   for (const lane of assignments) {
     const rel = `.aioson/context/parallel/agent-${lane.lane}.status.md`;
     const lanePath = path.join(targetDir, rel);
     const current = await fs.readFile(lanePath, 'utf8');
+    laneStatusByIndex.set(lane.lane, current);
+    enrichedAssignments.push({
+      ...lane,
+      owner: extractMetadata(current, 'owner', `lane-${lane.lane}`),
+      dependsOn: extractStatusDependencyItems(current),
+      writePaths: extractStatusWritePathItems(current),
+      mergeRank: extractStatusMergeRank(current, lane.lane)
+    });
+  }
+
+  const laneEntries = buildLaneOwnershipEntries(enrichedAssignments);
+
+  for (const lane of assignments) {
+    const rel = `.aioson/context/parallel/agent-${lane.lane}.status.md`;
+    const lanePath = path.join(targetDir, rel);
+    const current = laneStatusByIndex.get(lane.lane);
+    const laneEntry = laneEntries.find((item) => item.lane === lane.lane);
     let next = replaceScopeSection(current, lane.items);
     next = updateTimestamp(next, generatedAt);
+    next = replaceMetadataLine(next, 'owner', laneEntry.owner);
+    next = replaceSection(next, 'Ownership', [
+      `- lane_key: ${laneEntry.lane_key}`,
+      `- scope_keys: ${laneEntry.scope_keys.length > 0 ? laneEntry.scope_keys.join(', ') : '[unassigned]'}`,
+      `- write_scope: ${laneEntry.scope_labels.length > 0 ? laneEntry.scope_labels.join(' | ') : '[unassigned]'}`,
+      `- write_paths: ${laneEntry.write_paths.length > 0 ? laneEntry.write_paths.join(', ') : '[unassigned]'}`
+    ]);
+    next = replaceSection(next, 'Merge', [
+      `- merge_rank: ${laneEntry.merge_rank}`,
+      '- merge_strategy: lane-index-asc'
+    ]);
     if (!dryRun) {
       await fs.writeFile(lanePath, next, 'utf8');
     }
     filesUpdated.push(rel);
   }
 
+  const workspaceManifest = buildWorkspaceManifest({
+    projectName,
+    classification: classification || 'MEDIUM',
+    workers,
+    generatedAt,
+    lanes: laneEntries,
+    sourceFile: sourceFile.relPath
+  });
+  const ownershipMap = buildOwnershipMap({
+    generatedAt,
+    lanes: laneEntries
+  });
+  const mergePlan = buildMergePlan({
+    generatedAt,
+    lanes: laneEntries,
+    sourceFile: sourceFile.relPath
+  });
+  const machineFiles = [
+    {
+      rel: WORKSPACE_MANIFEST_RELATIVE_PATH,
+      payload: workspaceManifest
+    },
+    {
+      rel: OWNERSHIP_MAP_RELATIVE_PATH,
+      payload: ownershipMap
+    },
+    {
+      rel: MERGE_PLAN_RELATIVE_PATH,
+      payload: mergePlan
+    }
+  ];
+
+  for (const file of machineFiles) {
+    if (!dryRun) {
+      await fs.writeFile(path.join(targetDir, file.rel), `${JSON.stringify(file.payload, null, 2)}\n`, 'utf8');
+    }
+    filesUpdated.push(file.rel);
+  }
+
   const sharedPath = path.join(parallelDir, 'shared-decisions.md');
   if (await exists(sharedPath)) {
     const sharedContent = await fs.readFile(sharedPath, 'utf8');
@@ -335,9 +408,15 @@ async function runParallelAssign({ args, options = {}, logger, t }) {
     assignments: assignments.map((item) => ({
       lane: item.lane,
       file: `.aioson/context/parallel/agent-${item.lane}.status.md`,
-      items: item.items
+      items: item.items,
+      writePaths: (laneEntries.find((laneEntry) => laneEntry.lane === item.lane) || {}).write_paths || []
     })),
-    filesUpdated
+    filesUpdated,
+    machineFiles: {
+      workspaceManifest: WORKSPACE_MANIFEST_RELATIVE_PATH,
+      ownershipMap: OWNERSHIP_MAP_RELATIVE_PATH,
+      mergePlan: MERGE_PLAN_RELATIVE_PATH
+    }
   };
 
   if (!dryRun) {
@@ -361,7 +440,8 @@ async function runParallelAssign({ args, options = {}, logger, t }) {
         extractionMethod: output.extractionMethod,
         fallbackUsed: output.fallbackUsed,
         scopeCount: output.scopeCount,
-        filesUpdated
+        filesUpdated,
+        machineFiles: output.machineFiles
       }
     });
   }