@aria_asi/cli 0.2.40 → 0.2.41

package/src/connectors/codebase-awareness.ts

@@ -1,18 +1,33 @@
-import { execFileSync } from 'child_process';
+import { execFileSync, spawn } from 'node:child_process';
 import { createHash } from 'crypto';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
 import * as path from 'path';
 import { fileURLToPath } from 'node:url';
 import type { AriaConfig, LinkedRepo } from '../config.js';
 import { loadConfig, saveConfig } from '../config.js';
 import { scanCodebase, schemaImageToText, watchCodebase } from '../codebase-scanner.js';
+import type { WatchChangeMetadata } from '../codebase-scanner.js';
 
 const ARIA_DIR = path.join(homedir(), '.aria');
 const BIN_DIR = path.join(ARIA_DIR, 'bin');
+const ATLAS_BIN = process.env.ARIA_CODEBASE_AWARENESS_ATLAS_BIN || path.join(ARIA_DIR, 'atlas', 'bin', 'atlas');
 const ENV_PATH = path.join(ARIA_DIR, 'codebase-awareness.env');
 const STATE_PATH = path.join(ARIA_DIR, 'codebase-awareness-state.json');
 const INDEX_PATH = path.join(ARIA_DIR, 'codebase-awareness-index.json');
+const MAX_DELTA_PATHS_PER_EVENT = 16;
+const MAX_DELTA_QUEUE_SIZE = 128;
+const DELTA_INGEST_CONCURRENCY = 2;
+const MAX_DELTA_RECENT_ERRORS = 12;
+const ATLAS_DELTA_JSON_ARGS = ['--json'] as const;
+
+interface AtlasDeltaTask {
+  repoRoot: string;
+  path: string;
+  eventId: string;
+  mode: string;
+  eventNames: string[];
+}
 
 type AwarenessStatus = 'idle' | 'watching' | 'scanning' | 'degraded' | 'error';
 const HEARTBEAT_INTERVAL_MS = Math.max(5_000, Number(process.env.ARIA_CODEBASE_AWARENESS_HEARTBEAT_MS || '15000'));
@@ -38,6 +53,16 @@ interface AwarenessState {
   watchedRepos: string[];
   repoSnapshots: RepoSnapshot[];
   lastError: string | null;
+  lastDeltaIngestAt: string | null;
+  lastDeltaIngestPath: string | null;
+  lastDeltaIngestEventId: string | null;
+  lastDeltaIngestNoop: boolean;
+  lastDeltaIngestNoopReason: string | null;
+  deltaIngestTotal: number;
+  deltaIngestSuccess: number;
+  deltaIngestFailures: number;
+  deltaIngestSkipped: number;
+  deltaIngestRecentErrors: string[];
   updatedAt: string;
   daemon?: {
     pid: number;
@@ -79,6 +104,16 @@ function defaultState(): AwarenessState {
     watchedRepos: [],
     repoSnapshots: [],
     lastError: null,
+    lastDeltaIngestAt: null,
+    lastDeltaIngestPath: null,
+    lastDeltaIngestEventId: null,
+    lastDeltaIngestNoop: true,
+    lastDeltaIngestNoopReason: null,
+    deltaIngestTotal: 0,
+    deltaIngestSuccess: 0,
+    deltaIngestFailures: 0,
+    deltaIngestSkipped: 0,
+    deltaIngestRecentErrors: [],
     updatedAt: new Date(0).toISOString(),
   };
 }
@@ -91,6 +126,16 @@ function readState(): AwarenessState {
       watchedRepos: Array.isArray(parsed.watchedRepos) ? parsed.watchedRepos : [],
       repoSnapshots: Array.isArray(parsed.repoSnapshots) ? parsed.repoSnapshots as RepoSnapshot[] : [],
       lastError: parsed.lastError || null,
+      lastDeltaIngestAt: parsed.lastDeltaIngestAt || null,
+      lastDeltaIngestPath: parsed.lastDeltaIngestPath || null,
+      lastDeltaIngestEventId: parsed.lastDeltaIngestEventId || null,
+      lastDeltaIngestNoop: Boolean(parsed.lastDeltaIngestNoop ?? true),
+      lastDeltaIngestNoopReason: parsed.lastDeltaIngestNoopReason || null,
+      deltaIngestTotal: typeof parsed.deltaIngestTotal === 'number' ? parsed.deltaIngestTotal : 0,
+      deltaIngestSuccess: typeof parsed.deltaIngestSuccess === 'number' ? parsed.deltaIngestSuccess : 0,
+      deltaIngestFailures: typeof parsed.deltaIngestFailures === 'number' ? parsed.deltaIngestFailures : 0,
+      deltaIngestSkipped: typeof parsed.deltaIngestSkipped === 'number' ? parsed.deltaIngestSkipped : 0,
+      deltaIngestRecentErrors: Array.isArray(parsed.deltaIngestRecentErrors) ? parsed.deltaIngestRecentErrors : [],
       updatedAt: parsed.updatedAt || new Date(0).toISOString(),
       daemon: parsed.daemon,
     };
@@ -103,6 +148,236 @@ function compactError(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
+let atlasDeltaEventCounter = 0;
+const atlasDeltaQueue: AtlasDeltaTask[] = [];
+let atlasDeltaInFlight = 0;
+
+function nextDeltaEventId(): string {
+  atlasDeltaEventCounter += 1;
+  return `delta-${Date.now().toString(36)}-${atlasDeltaEventCounter.toString(36)}`;
+}
+
+function pruneRecentErrors(errors: string[]): string[] {
+  return errors.slice(0, MAX_DELTA_RECENT_ERRORS);
+}
+
+function markDeltaNoop(repoRoot: string, eventId: string, reason: string, skipped = 1): void {
+  const current = readState();
+  writeState({
+    lastDeltaIngestAt: new Date().toISOString(),
+    lastDeltaIngestPath: null,
+    lastDeltaIngestEventId: eventId,
+    lastDeltaIngestNoop: true,
+    lastDeltaIngestNoopReason: reason,
+    deltaIngestSkipped: current.deltaIngestSkipped + Math.max(skipped, 0),
+  });
+}
+
+function markDeltaQueued(filePath: string, eventId: string): void {
+  const current = readState();
+  writeState({
+    lastDeltaIngestAt: new Date().toISOString(),
+    lastDeltaIngestPath: filePath,
+    lastDeltaIngestEventId: eventId,
+    lastDeltaIngestNoop: false,
+    lastDeltaIngestNoopReason: null,
+    deltaIngestTotal: current.deltaIngestTotal + 1,
+  });
+}
+
+function parseAtlasDeltaResult(stdout: string): {
+  atlasEventId: string | null;
+  noop: boolean;
+  noopReason: string | null;
+} {
+  try {
+    const jsonLine = stdout
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter((line) => line.startsWith('{') && line.endsWith('}'))
+      .at(-1);
+    const parsed = JSON.parse(jsonLine || stdout);
+    const delta = parsed?.delta_ingest || {};
+    return {
+      atlasEventId: delta.event_id !== null && delta.event_id !== undefined
+        ? String(delta.event_id)
+        : delta.high_watermark !== null && delta.high_watermark !== undefined
+          ? String(delta.high_watermark)
+          : null,
+      noop: Boolean(delta.noop),
+      noopReason: typeof delta.reason === 'string' ? delta.reason : null,
+    };
+  } catch {
+    return { atlasEventId: null, noop: false, noopReason: null };
+  }
+}
+
+function markDeltaSuccess(filePath: string, eventId: string, result?: {
+  atlasEventId: string | null;
+  noop: boolean;
+  noopReason: string | null;
+}): void {
+  const current = readState();
+  writeState({
+    lastDeltaIngestAt: new Date().toISOString(),
+    lastDeltaIngestPath: filePath,
+    lastDeltaIngestEventId: result?.atlasEventId || eventId,
+    lastDeltaIngestNoop: Boolean(result?.noop),
+    lastDeltaIngestNoopReason: result?.noopReason || null,
+    deltaIngestSuccess: current.deltaIngestSuccess + 1,
+    lastError: null,
+  });
+}
+
+function markDeltaFailure(repoRoot: string, eventId: string, filePath: string, message: string): void {
+  const current = readState();
+  const errorMessage = `${message}${filePath ? ` (${filePath})` : ''}`;
+  const nextErrors = pruneRecentErrors([`${new Date().toISOString()} [${repoRoot}] [${eventId}] ${errorMessage}`, ...current.deltaIngestRecentErrors]);
+  writeState({
+    lastDeltaIngestAt: new Date().toISOString(),
+    lastDeltaIngestPath: filePath || null,
+    lastDeltaIngestEventId: eventId,
+    lastDeltaIngestNoop: filePath ? false : true,
+    lastDeltaIngestNoopReason: filePath ? null : errorMessage,
+    deltaIngestFailures: current.deltaIngestFailures + 1,
+    deltaIngestRecentErrors: nextErrors,
+    lastError: `Atlas delta ingest failure: ${errorMessage}`,
+  });
+}
+
+function normalizeDeltaFilePath(repoRoot: string, candidate: string): string | null {
+  if (!candidate || candidate.trim().length === 0) return null;
+  const resolved = path.isAbsolute(candidate) ? path.resolve(candidate) : path.resolve(repoRoot, candidate);
+  const rel = path.relative(repoRoot, resolved);
+  const outsideRepo = rel === '' || rel.startsWith(`..${path.sep}`) || rel === '..' || path.isAbsolute(rel);
+  if (outsideRepo) {
+    return null;
+  }
+  try {
+    const stat = statSync(resolved);
+    if (!stat.isFile()) return null;
+  } catch {
+    return null;
+  }
+  return resolved;
+}
+
+function collectDeltaFilePaths(repoRoot: string, metadata: WatchChangeMetadata): string[] {
+  const files = new Set<string>();
+  for (const changedPath of metadata.changedPaths) {
+    const normalized = normalizeDeltaFilePath(repoRoot, changedPath);
+    if (normalized) files.add(normalized);
+  }
+  return Array.from(files).slice(0, MAX_DELTA_PATHS_PER_EVENT);
+}
+
+function runAtlasDeltaIngest(task: AtlasDeltaTask): Promise<void> {
+  return new Promise((resolve) => {
+    const child = spawn(ATLAS_BIN, [
+      'delta-ingest',
+      'file',
+      task.path,
+      '--root',
+      task.repoRoot,
+      ...ATLAS_DELTA_JSON_ARGS,
+    ], { stdio: ['ignore', 'pipe', 'pipe'] });
+
+    let stderr = '';
+    let stdout = '';
+    let settled = false;
+    child.stdout.on('data', (chunk: Buffer) => { stdout += chunk.toString('utf8'); });
+    child.stderr.on('data', (chunk: Buffer) => { stderr += chunk.toString('utf8'); });
+
+    const finish = (code: number | null, signal: NodeJS.Signals | null, error?: unknown): void => {
+      if (settled) return;
+      settled = true;
+      if (error || code !== 0 || signal) {
+        const message = error
+          ? compactError(error)
+          : `exit ${code} signal ${String(signal ?? 'none')}`;
+        const detail = stdout.trim() || stderr.trim() || message;
+        markDeltaFailure(task.repoRoot, task.eventId, task.path, detail);
+      } else {
+        markDeltaSuccess(task.path, task.eventId, parseAtlasDeltaResult(stdout));
+      }
+      resolve();
+    };
+
+    child.on('error', (error) => {
+      finish(null, null, error);
+    });
+    child.on('close', (code, signal) => {
+      finish(code, signal);
+    });
+  });
+}
+
+function pumpAtlasDeltaQueue(): void {
+  while (atlasDeltaInFlight < DELTA_INGEST_CONCURRENCY && atlasDeltaQueue.length > 0) {
+    const task = atlasDeltaQueue.shift();
+    if (!task) return;
+    atlasDeltaInFlight += 1;
+    runAtlasDeltaIngest(task).finally(() => {
+      atlasDeltaInFlight -= 1;
+      pumpAtlasDeltaQueue();
+    });
+  }
+}
+
+function scheduleAtlasDeltaIngest(repoRoot: string, metadata: WatchChangeMetadata): void {
+  const eventId = nextDeltaEventId();
+  const candidates = collectDeltaFilePaths(repoRoot, metadata);
+  const candidateCount = metadata.changedPaths.length;
+  const skippedFromCandidateResolution = Math.max(0, candidateCount - candidates.length);
+
+  if (!candidates.length) {
+    markDeltaNoop(
+      repoRoot,
+      eventId,
+      metadata.reason || (metadata.mode === 'poll' ? 'poll with no path' : 'no delta file candidate'),
+      skippedFromCandidateResolution,
+    );
+    return;
+  }
+
+  let queuedCount = 0;
+  for (const filePath of candidates) {
+    if (atlasDeltaQueue.length >= MAX_DELTA_QUEUE_SIZE) {
+      continue;
+    }
+    atlasDeltaQueue.push({ repoRoot, path: filePath, eventId, mode: metadata.mode, eventNames: metadata.events });
+    markDeltaQueued(filePath, eventId);
+    queuedCount += 1;
+  }
+
+  if (queuedCount < candidates.length) {
+    const skippedFromQueue = candidates.length - queuedCount;
+    const current = readState();
+    if (queuedCount > 0) {
+      writeState({
+        lastDeltaIngestAt: new Date().toISOString(),
+        lastDeltaIngestEventId: eventId,
+        lastDeltaIngestNoop: false,
+        lastDeltaIngestNoopReason: null,
+        deltaIngestSkipped: current.deltaIngestSkipped + skippedFromQueue,
+      });
+    } else {
+      markDeltaNoop(
+        repoRoot,
+        eventId,
+        `delta ingest queue full (max ${MAX_DELTA_QUEUE_SIZE})`,
+        skippedFromQueue,
+      );
+    }
+  }
+
+  if (skippedFromCandidateResolution > 0) {
+    const current = readState();
+    writeState({ deltaIngestSkipped: current.deltaIngestSkipped + skippedFromCandidateResolution });
+  }
+  pumpAtlasDeltaQueue();
+}
+
 function writeState(update: Partial<AwarenessState>): AwarenessState {
   const current = readState();
   const next: AwarenessState = {
@@ -134,27 +409,46 @@ function findRepoRoot(startDir: string): string | null {
   }
 }
 
+function isUsableWatchRoot(candidate: string): boolean {
+  const resolved = path.resolve(candidate);
+  return resolved !== homedir() && existsSync(resolved);
+}
+
+function isBroadHomePath(candidate: string): boolean {
+  return path.resolve(candidate) === homedir();
+}
+
+function uniqueWatchRoots(repos: Array<string | null | undefined>): string[] {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const repo of repos) {
+    if (!repo) continue;
+    const resolved = path.resolve(repo);
+    if (!isUsableWatchRoot(resolved) || seen.has(resolved)) continue;
+    seen.add(resolved);
+    out.push(resolved);
+  }
+  return out;
+}
+
 function resolveRepos(config?: AriaConfig, explicit?: string[], fallbackRepoPath?: string): string[] {
-  if (explicit?.length) return explicit.map((repo) => path.resolve(repo)).filter(looksLikeRepoRoot);
+  if (explicit?.length) return uniqueWatchRoots(explicit);
 
   const envRepos = process.env.ARIA_CODEBASE_AWARENESS_REPOS?.split(path.delimiter)
     .map((repo) => repo.trim())
     .filter(Boolean) || [];
-  if (envRepos.length) return envRepos.map((repo) => path.resolve(repo)).filter(looksLikeRepoRoot);
 
   const loaded = config || loadConfig();
   const configured = (loaded.repositories || [])
-    .map((repo) => path.resolve(repo.path))
-    .filter(looksLikeRepoRoot);
-  if (configured.length) return configured;
-
-  if (fallbackRepoPath) {
-    const resolvedFallback = findRepoRoot(fallbackRepoPath);
-    if (resolvedFallback) return [resolvedFallback];
-  }
+    .map((repo) => path.resolve(repo.path));
 
   const cwd = findRepoRoot(process.cwd());
-  return cwd ? [cwd] : [];
+  return uniqueWatchRoots([
+    ...envRepos,
+    ...configured,
+    fallbackRepoPath ? findRepoRoot(fallbackRepoPath) : null,
+    cwd,
+  ]);
 }
 
 function hashSchema(text: string): string {
@@ -189,15 +483,17 @@ async function applyRepoScan(repoRoot: string): Promise<RepoSnapshot> {
     lastScan,
   };
   const repositories = [
-    ...(config.repositories || []).filter((repo) => path.resolve(repo.path) !== repoRoot),
+    ...(config.repositories || []).filter((repo) => path.resolve(repo.path) !== repoRoot && !isBroadHomePath(repo.path)),
     nextRepo,
   ];
+  const schemaImages = { ...(config.schemaImages || {}) };
+  delete schemaImages[path.basename(homedir())];
 
   saveConfig({
     ...config,
     repositories,
     schemaImages: {
-      ...(config.schemaImages || {}),
+      ...schemaImages,
       [image.projectName]: schemaText,
     },
   });
@@ -219,7 +515,7 @@ async function applyRepoScan(repoRoot: string): Promise<RepoSnapshot> {
   const current = readState();
   const nextSnapshots = [
     snapshot,
-    ...current.repoSnapshots.filter((entry) => path.resolve(entry.path) !== repoRoot),
+    ...current.repoSnapshots.filter((entry) => path.resolve(entry.path) !== repoRoot && !isBroadHomePath(entry.path)),
   ];
   writeState({
     status: 'watching',
@@ -307,11 +603,7 @@ export async function startCodebaseAwarenessDaemon(options: {
       }
     }
 
-    const current = readState();
-    const repoSnapshots = [
-      ...snapshots,
-      ...current.repoSnapshots.filter((entry) => !snapshots.some((snapshot) => path.resolve(snapshot.path) === path.resolve(entry.path))),
-    ];
+    const repoSnapshots = snapshots;
     writeDaemonState(failures.length ? 'degraded' : 'watching', {
       repoSnapshots,
       lastError: failures.length ? `${reason}: ${failures.join(' | ')}` : null,
@@ -339,19 +631,21 @@ export async function startCodebaseAwarenessDaemon(options: {
       try {
         const handle = watchCodebase(
           repo,
-          (image) => {
+          (image, metadata) => {
             const schemaText = schemaImageToText(image);
             const scanHash = hashSchema(schemaText);
             const lastScan = new Date().toISOString();
             const config = loadConfig();
             const repositories = [
-              ...(config.repositories || []).filter((entry) => path.resolve(entry.path) !== repo),
+              ...(config.repositories || []).filter((entry) => path.resolve(entry.path) !== repo && !isBroadHomePath(entry.path)),
               { path: repo, name: image.projectName, scanHash, lastScan },
             ];
+            const schemaImages = { ...(config.schemaImages || {}) };
+            delete schemaImages[path.basename(homedir())];
             const nextConfig = {
               ...config,
               repositories,
-              schemaImages: { ...(config.schemaImages || {}), [image.projectName]: schemaText },
+              schemaImages: { ...schemaImages, [image.projectName]: schemaText },
             };
             saveConfig(nextConfig);
 
@@ -369,8 +663,12 @@ export async function startCodebaseAwarenessDaemon(options: {
               orm: image.orm || null,
               architecture: architectureSummary(image),
             };
-            const repoSnapshots = [snapshot, ...current.repoSnapshots.filter((entry) => path.resolve(entry.path) !== repo)];
+            const repoSnapshots = [
+              snapshot,
+              ...current.repoSnapshots.filter((entry) => path.resolve(entry.path) !== repo && repos.includes(path.resolve(entry.path))),
+            ];
             writeDaemonState('watching', { repoSnapshots, lastError: null });
+            scheduleAtlasDeltaIngest(repo, metadata);
             writeIndex({ generatedAt: new Date().toISOString(), reason: 'watch-change', watchedRepos: repos, repoSnapshots, schemaImages: nextConfig.schemaImages || {} });
           },
           {
@@ -387,6 +685,7 @@ export async function startCodebaseAwarenessDaemon(options: {
         );
         handles.set(repo, handle);
         watcherModes[repo] = handle.mode;
+        writeDaemonState('watching', { lastError: null });
       } catch (error) {
         writeDaemonState('degraded', { lastError: `${repo} watcher init: ${compactError(error)}` });
       }
@@ -446,6 +745,7 @@ function installSystemdUserService(logs: string[]): void {
   try {
     execFileSync(systemctlPath, ['--user', 'daemon-reload'], { stdio: 'ignore' });
     execFileSync(systemctlPath, ['--user', 'enable', '--now', 'aria-codebase-awareness.service'], { stdio: 'ignore' });
+    execFileSync(systemctlPath, ['--user', 'restart', 'aria-codebase-awareness.service'], { stdio: 'ignore' });
     logs.push('Enabled and started systemd user service: aria-codebase-awareness.service');
   } catch (error) {
     logs.push(`⚠ codebase awareness service installed but not activated: ${error instanceof Error ? error.message : String(error)}`);