elanous 0.2.38 → 0.2.40

package/scripts/dead-code/report.ts

@@ -0,0 +1,169 @@
+#!/usr/bin/env bun
+/** Conservative multi-entrypoint reachability inventory. This command NEVER deletes files. */
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import ts from 'typescript';
+
+export interface RootGroup { name: string; roots: string[]; configuration?: string }
+export interface ModuleGap { importer: string; specifier: string; kind: 'unresolved' | 'dynamic' }
+export interface GroupResult { name: string; roots: string[]; reachable: string[]; gaps: ModuleGap[] }
+export interface ReachabilityReport {
+  schemaVersion: 1;
+  trackedFiles: number;
+  groups: GroupResult[];
+  unionReachable: string[];
+  unknownKeep: string[];
+  unresolved: ModuleGap[];
+  dynamic: ModuleGap[];
+  /** Never interpreted as safe-to-delete: configuration/runtime loaders cannot be exhaustively statically enumerated. */
+  unclassifiedKeep: string[];
+  overlaps: Record<string, string[]>;
+  deletions: 0;
+}
+
+const moduleFile = (p: string) => /\.[cm]?[jt]sx?$/.test(p);
+const testFile = (p: string) => /(?:^|\/)(?:__tests__|__fixtures__|test|tests|fixtures)\//.test(p) || /\.(?:test|spec)\.[cm]?[jt]sx?$/.test(p);
+const normalized = (p: string) => p.replaceAll('\\', '/');
+const sorted = (items: Iterable<string>) => [...new Set(items)].sort();
+
+export function trackedModules(root: string): string[] {
+  return execFileSync('git', ['ls-files', '-z', '--cached'], { cwd: root, maxBuffer: 16 * 1024 * 1024 })
+    .toString().split('\0').filter(moduleFile).filter(Boolean).map(normalized).sort();
+}
+
+function loadOptions(config: string | undefined, root: string): ts.CompilerOptions {
+  if (!config || !existsSync(join(root, config))) return { moduleResolution: ts.ModuleResolutionKind.Bundler, module: ts.ModuleKind.ESNext, allowJs: true };
+  const filename = join(root, config);
+  const source = ts.readConfigFile(filename, ts.sys.readFile);
+  if (source.error) throw new Error(ts.flattenDiagnosticMessageText(source.error.messageText, '\n'));
+  const parsed = ts.parseJsonConfigFileContent(source.config, ts.sys, dirname(filename), undefined, filename);
+  if (parsed.errors.length) throw new Error(parsed.errors.map(e => ts.flattenDiagnosticMessageText(e.messageText, '\n')).join('\n'));
+  return parsed.options;
+}
+
+export function inventoryRoots(root: string, files: readonly string[]): RootGroup[] {
+  const groups: RootGroup[] = [
+    { name: 'cli', roots: ['bin/elanous.mjs', 'src/index.ts', 'src/light-cli.ts'], configuration: 'tsconfig.json' },
+    { name: 'scripts', roots: files.filter(p => p.startsWith('scripts/') && !testFile(p)), configuration: 'tsconfig.json' },
+    { name: 'pwa', roots: files.filter(p => /^apps\/pwa\/src\/(app\/(?:.*\/)?(?:page|layout|route|loading|error|not-found|template|default)|middleware|instrumentation)\.[jt]sx?$/.test(p)), configuration: 'apps/pwa/tsconfig.json' },
+    { name: 'desktop', roots: ['apps/desktop/src/main.ts'], configuration: 'apps/desktop/tsconfig.json' },
+  ];
+  for (const app of sorted(files.filter(p => /^apps\/[^/]+\/src\/(?:main|index)\.[jt]sx?$/.test(p)))) {
+    if (app.startsWith('apps/desktop/') || app.startsWith('apps/pwa/')) continue;
+    groups.push({ name: `app:${app.split('/')[1]}`, roots: [app], configuration: `apps/${app.split('/')[1]}/tsconfig.json` });
+  }
+  // Manifest-declared paths are roots even when no TS import refers to them.
+  const manifests = execFileSync('git', ['ls-files', '-z', '--', 'plugins/*/plugin.json', 'plugins/*/manifest.json'], { cwd: root }).toString().split('\0').filter(Boolean);
+  const plugins: string[] = [];
+  for (const path of manifests) {
+    const manifest = JSON.parse(readFileSync(join(root, path), 'utf8')) as { entry?: string; main?: string };
+    const declared = manifest.entry ?? manifest.main;
+    if (!declared) continue;
+    const entry = normalized(join(dirname(path), declared));
+    // Missing manifest entries remain roots and become explicit unresolved/unknown gaps.
+    plugins.push(entry);
+  }
+  groups.push({ name: 'plugins', roots: sorted(plugins), configuration: 'tsconfig.json' });
+  // Runtime loaders and independently launched ACP boot are not necessarily in the CLI's import graph.
+  groups.push({ name: 'runtime', roots: ['src/boot/acp-server.ts', 'src/plugin-declarative/discovery.ts', 'src/self-implement/graph-catalog.ts', 'src/graph-runner/runner.ts'], configuration: 'tsconfig.json' });
+  return groups;
+}
+
+export function analyzeReachability(root: string, files: readonly string[], groups: readonly RootGroup[]): ReachabilityReport {
+  const tracked = new Set(files.map(normalized));
+  const cache = new Map<string, ts.SourceFile>();
+  const results: GroupResult[] = [];
+  const unknown = new Set<string>();
+  for (const group of groups) {
+    const options = loadOptions(group.configuration, root);
+    const reachable = new Set<string>();
+    const gaps: ModuleGap[] = [];
+    const queue = [...group.roots];
+    const host = ts.createCompilerHost(options, true);
+    const moduleCache = ts.createModuleResolutionCache(root, s => s, options);
+    while (queue.length) {
+      const path = queue.pop()!;
+      if (reachable.has(path)) continue;
+      if (!tracked.has(path)) {
+        gaps.push({ importer: `(root:${group.name})`, specifier: path, kind: 'unresolved' });
+        unknown.add(path);
+        continue;
+      }
+      reachable.add(path);
+      const absolute = join(root, path);
+      let source = cache.get(path);
+      if (!source) {
+        source = ts.createSourceFile(absolute, readFileSync(absolute, 'utf8'), ts.ScriptTarget.Latest, true, path.endsWith('x') ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+        cache.set(path, source);
+      }
+      const inspect = (specifier: ts.Expression) => {
+        if (!ts.isStringLiteralLike(specifier)) {
+          gaps.push({ importer: path, specifier: specifier.getText(source), kind: 'dynamic' }); unknown.add(path); return;
+        }
+        const text = specifier.text;
+        const resolved = ts.resolveModuleName(text, absolute, options, host, moduleCache).resolvedModule?.resolvedFileName;
+        const name = resolved ? normalized(relative(root, resolved)) : '';
+        if (name && tracked.has(name)) queue.push(name);
+        else if (text.startsWith('.') || text.startsWith('/') || text.startsWith('@/')) {
+          gaps.push({ importer: path, specifier: text, kind: 'unresolved' }); unknown.add(path);
+        }
+        // External packages are outside the tracked-source deletion domain.
+      };
+      const walk = (node: ts.Node) => {
+        if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) && node.moduleSpecifier) inspect(node.moduleSpecifier);
+        else if (ts.isImportEqualsDeclaration(node) && ts.isExternalModuleReference(node.moduleReference) && node.moduleReference.expression) inspect(node.moduleReference.expression);
+        else if (ts.isCallExpression(node) && (node.expression.kind === ts.SyntaxKind.ImportKeyword || (ts.isIdentifier(node.expression) && node.expression.text === 'require'))) {
+          if (node.arguments[0]) inspect(node.arguments[0]);
+          else { gaps.push({ importer: path, specifier: '(missing argument)', kind: 'dynamic' }); unknown.add(path); }
+        }
+        ts.forEachChild(node, walk);
+      };
+      walk(source);
+    }
+    results.push({ name: group.name, roots: sorted(group.roots), reachable: sorted(reachable), gaps });
+  }
+  const uses = new Map<string, string[]>();
+  for (const group of results) for (const p of group.reachable) uses.set(p, [...(uses.get(p) ?? []), group.name]);
+  const gaps = results.flatMap(r => r.gaps);
+  const uniqueGaps = (kind: ModuleGap['kind']) => [...new Map(gaps.filter(g => g.kind === kind).map(g => [`${g.importer}\0${g.specifier}`, g])).values()]
+    .sort((a, b) => a.importer.localeCompare(b.importer) || a.specifier.localeCompare(b.specifier));
+  // The rest are *not* dead code: lazy/config/graph/plugin discovery and non-TS launchers are open-world inputs.
+  const unclassified = files.filter(p => !uses.has(p));
+  return {
+    schemaVersion: 1, trackedFiles: files.length, groups: results,
+    unionReachable: sorted(uses.keys()), unknownKeep: sorted([...unknown, ...unclassified]),
+    unresolved: uniqueGaps('unresolved'), dynamic: uniqueGaps('dynamic'),
+    unclassifiedKeep: sorted(unclassified),
+    overlaps: Object.fromEntries([...uses].filter(([, v]) => v.length > 1).sort(([a], [b]) => a.localeCompare(b))),
+    deletions: 0,
+  };
+}
+
+export function renderMarkdown(report: ReachabilityReport): string {
+  const lines = ['# Multi-entrypoint reachability inventory', '', 'This is an observation, not a safe-to-delete list. Deletions: 0.', '',
+    `Tracked source: ${report.trackedFiles}; union reachable: ${report.unionReachable.length}; unknown/keep: ${report.unknownKeep.length}; unresolved: ${report.unresolved.length}; dynamic: ${report.dynamic.length}.`, '',
+    '| Root family | roots | reachable | unknown edges |', '|---|---:|---:|---:|'];
+  for (const g of report.groups) lines.push(`| ${g.name} | ${g.roots.length} | ${g.reachable.length} | ${g.gaps.length} |`);
+  lines.push('', 'Unclassified source, dynamic imports, configuration/graph loaders and resolution gaps remain unknown/keep; no deletion candidate is asserted.', '');
+  return lines.join('\n');
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const root = resolve(process.argv[2] ?? '.');
+  const files = trackedModules(root);
+  const report = analyzeReachability(root, files, inventoryRoots(root, files));
+  const json = JSON.stringify(report, null, 2);
+  if (process.argv.includes('--json')) process.stdout.write(json + '\n');
+  else if (process.argv.includes('--md')) process.stdout.write(renderMarkdown(report));
+  else if (process.argv.includes('--output')) {
+    const index = process.argv.indexOf('--output');
+    const target = process.argv[index + 1];
+    if (!target || target.startsWith('--')) throw new Error('--output requires a path');
+    const output = resolve(target);
+    writeFileSync(output + '.json', json + '\n');
+    writeFileSync(output + '.md', renderMarkdown(report));
+    console.log(`report: ${output}.json / ${output}.md`);
+  } else process.stdout.write(renderMarkdown(report));
+}

package/scripts/lib/morning-report-options.ts

@@ -12,10 +12,9 @@
 //     경로(model 미지정 ⇒ providerFor(cfg))를 그대로 보존한다. 값이 없거나 빈 값이면
 //     parseArgv 오류를 던져 기본 모델로 조용히 실행되지 않도록 한다.
 //
-// ⛔ 의도된 경계(비연결 선언): 이 유닛은 «정의 + 단위시험» 에서 멈춘다.
-//   scripts/morning-report.ts 탑레벨(CLI 진입) → composeMorningReport(..., { model }) 배선은
-//   의존 형제 샤드(task:d0183079b142)의 몫이다. 지금 이 유닛을 실행 경로에서 부르는 곳은
-//   scripts/lib/morning-report-options.test.ts(bun test, in-process) 다.
+// ✅ 배선 완료(SWAP-BENCH-CRON): scripts/morning-report.ts 탑레벨(CLI 진입)이 이 파서를
+//   호출해 --narrative-model 값을 composeMorningReport(..., { model }) 로 넘긴다.
+//   배선 계약 시험은 test/morning-report.test.ts(mock 무대)가 누른다.
 
 import { parseArgv, type ArgvContract } from './argv.js';
 

package/scripts/lib/tui-regress-evidence.ts

@@ -0,0 +1,56 @@
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export interface TuiRegressFailureEvidence {
+  runId: string;
+  event: string;
+  verificationCommand: string;
+  artifactRoot: string;
+  configDir: string;
+  check: { id: string; title: string; role: string };
+  screens: Record<string, string>;
+  pty: { cols: number; rows: number; bootMs: number };
+  environment: {
+    driveTui: string;
+    nodeEnv: string | null;
+    credentialVariablesPresent: string[];
+  };
+  verdict: { ok: boolean; reason: string };
+}
+
+function redactConfig(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(redactConfig);
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(Object.entries(value).map(([key, child]) => [
+      key,
+      /api.?key|token|secret|password|credential/i.test(key) ? '[REDACTED]' : redactConfig(child),
+    ]));
+  }
+  return value;
+}
+
+export function preserveTuiRegressFailure(input: TuiRegressFailureEvidence): string {
+  mkdirSync(input.artifactRoot, { recursive: true });
+  const artifactDir = mkdtempSync(join(input.artifactRoot, `${input.check.id}-`));
+  const screensDir = join(artifactDir, 'screens');
+  mkdirSync(screensDir);
+  for (const [name, screen] of Object.entries(input.screens)) writeFileSync(join(screensDir, `${name}.txt`), screen);
+
+  const configPath = join(input.configDir, 'config.json');
+  let effectiveConfig: unknown = { unavailable: !existsSync(configPath) };
+  if (existsSync(configPath)) {
+    try { effectiveConfig = redactConfig(JSON.parse(readFileSync(configPath, 'utf8'))); }
+    catch (error) { effectiveConfig = { parseError: String(error), bytes: readFileSync(configPath).byteLength }; }
+  }
+  writeFileSync(join(artifactDir, 'effective-config.json'), `${JSON.stringify(effectiveConfig, null, 2)}\n`);
+  writeFileSync(join(artifactDir, 'run.json'), `${JSON.stringify({
+    runId: input.runId,
+    event: input.event,
+    verificationCommand: input.verificationCommand,
+    check: input.check,
+    pty: input.pty,
+    environment: input.environment,
+    verdict: input.verdict,
+  }, null, 2)}\n`);
+  return artifactDir;
+}

package/scripts/morning-report.ts

@@ -4,12 +4,14 @@
 //   bun run scripts/morning-report.ts --dry        # compose only (stdout, no send)
 //   bun run scripts/morning-report.ts --no-narrate # skip the LLM 시장서사 layer
 //   bun run scripts/morning-report.ts --no-upload  # skip S3 상세 업로드(로컬 미리보기)
+//   bun run scripts/morning-report.ts --narrative-model <model>  # 시장서사 LLM 모델 명시(A/B)
 
 import { composeMorningReport } from '../src/domains/morning-report.js';
 import { explainReportRoute, sendTelegramReport, sendReportPhoto } from '../src/telegram-report.js';
 import { getUserConfig } from '../src/user-config.js';
 import { getFirecrawlConfig } from '../src/registry/discovery/config.js';
 import { captureFinvizMapImageUrl } from '../src/domains/finviz-image.js';
+import { parseNarrativeModelArg } from './lib/morning-report-options.js';
 
 import { registerStandaloneLogSink } from '../src/domains/standalone-log-sink.js';
 
@@ -20,6 +22,8 @@ const dry = process.argv.includes('--dry');
 const cfg = getUserConfig();
 const narrate = cfg.finance.morningNarrative !== false && !process.argv.includes('--no-narrate');
 const upload = !process.argv.includes('--no-upload');
+// --narrative-model X / =X — 값이 없으면 parseNarrativeModelArg 가 throw(기본 모델로 조용히 대체하지 않는다).
+const model = parseNarrativeModelArg(process.argv.slice(2));
 
 // finviz S&P 히트맵 이미지 — HTML 상세 리포트에 임베드 + 텔레그램 포토로도 발송. 키 있을 때만.
 let heatmapImageUrl: string | undefined;
@@ -31,7 +35,7 @@ if (cfg.finance.morningHeatmapImage !== false) {
   } catch (e) { console.error(`[morning-report] heatmap capture error: ${e instanceof Error ? e.message : String(e)}`); }
 }
 
-const report = await composeMorningReport(new Date(), { narrate, heatmapImageUrl, upload });
+const report = await composeMorningReport(new Date(), { narrate, heatmapImageUrl, upload, model });
 
 if (dry) {
   console.log(report);

package/scripts/public-export.ts

@@ -109,15 +109,23 @@ class PrivateRedactionError extends Error {
 
 function codeIdentifierRanges(file: string, text: string): Array<{ start: number; end: number; name: string }> {
   if (!CODE_FILE.test(file)) return [];
-  const scanner = ts.createScanner(ts.ScriptTarget.Latest, false,
-    /\.(?:tsx|jsx)$/iu.test(file) ? ts.LanguageVariant.JSX : ts.LanguageVariant.Standard, text);
+  // A raw scanner cannot track template-expression braces without rescanning. It can
+  // report words in later strings/comments as identifiers after a template literal.
+  // The parsed token tree has already resolved those boundaries.
+  const kind = /\.(?:tsx|jsx)$/iu.test(file) ? ts.ScriptKind.TSX
+    : /\.(?:js|mjs|cjs)$/iu.test(file) ? ts.ScriptKind.JS : ts.ScriptKind.TS;
+  const source = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, false, kind);
   const ranges: Array<{ start: number; end: number; name: string }> = [];
-  for (let token = scanner.scan(); token !== ts.SyntaxKind.EndOfFileToken; token = scanner.scan()) {
-    if (token === ts.SyntaxKind.Identifier || token === ts.SyntaxKind.PrivateIdentifier
-      || token >= ts.SyntaxKind.FirstKeyword && token <= ts.SyntaxKind.LastKeyword) {
-      ranges.push({ start: scanner.getTokenPos(), end: scanner.getTextPos(), name: scanner.getTokenText() });
+  const visit = (node: ts.Node): void => {
+    if (ts.isJSDoc(node)) return;
+    if (node.kind === ts.SyntaxKind.Identifier || node.kind === ts.SyntaxKind.PrivateIdentifier
+      || node.kind >= ts.SyntaxKind.FirstKeyword && node.kind <= ts.SyntaxKind.LastKeyword) {
+      ranges.push({ start: node.getStart(source), end: node.getEnd(), name: node.getText(source) });
+      return;
     }
-  }
+    for (const child of node.getChildren(source)) visit(child);
+  };
+  visit(source);
   return ranges;
 }
 

package/scripts/release-loop/export-check-node.ts

@@ -46,9 +46,27 @@ export function runExportCheck(run: CommandRunner = runCommand, repoRoot = proce
             step = 'build';
             const publicDir = join(out, 'export');
             symlinkSync(join(modulesRoot, 'node_modules'), join(publicDir, 'node_modules'), 'dir');
-            const pwaModules = join(modulesRoot, 'apps', 'pwa', 'node_modules');
-            if (!existsSync(pwaModules)) result = failed('build', 'PWA dependencies missing; run bun install --cwd apps/pwa in the release-loop repository');
-            else {
+            let pwaModules = join(root, 'apps', 'pwa', 'node_modules');
+            let pwaReady = existsSync(pwaModules);
+            if (!pwaReady) {
+              const installed = run('bun', ['install', '--cwd', join(root, 'apps', 'pwa'), '--frozen-lockfile'], root);
+              if (installed.status !== 0) {
+                // This path was absent before install. Remove partial output so a later retry cannot mistake it for a complete install.
+                let cleanupFailed = false;
+                try { rmSync(pwaModules, { recursive: true, force: true }); }
+                catch (error) {
+                  cleanupFailed = true;
+                  result = failed('build', `PWA dependency install partial-output cleanup: ${error instanceof Error ? error.message : String(error)}`, installed);
+                }
+                if (!cleanupFailed) result = failed('build', 'PWA dependency install', installed);
+              }
+              else {
+                pwaReady = existsSync(pwaModules);
+                if (!pwaReady) result = failed('build', 'PWA dependency install did not create apps/pwa/node_modules', installed);
+              }
+            }
+            if (pwaReady) {
+              pwaModules = realpathSync(pwaModules);
               if (existsSync(join(publicDir, 'apps', 'pwa'))) symlinkSync(pwaModules, join(publicDir, 'apps', 'pwa', 'node_modules'), 'dir');
               const built = run('bun', ['bin/elanous.mjs', 'nexus', 'build'], publicDir);
               result = built.status === 0 && existsSync(join(publicDir, 'apps', 'pwa', 'out', 'index.html'))