jeo-code 0.1.0 → 0.4.5

package/src/agent/context-files.ts

@@ -1,36 +1,333 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 
+import { IGNORED_DIRS } from "./tools";
+
+interface ContextItem {
+  filePath: string;
+  displayPath: string;
+  type: "cwd" | "nested" | "parent";
+  depth?: number;
+  distance?: number;
+  candidateName: string;
+}
+
 export interface ProjectContextFile {
   path: string;
   content: string;
 }
 
-export const CONTEXT_CANDIDATES = ["JEO.md", "AGENTS.md", ".joc/context.md", "CLAUDE.md"];
+export const CONTEXT_CANDIDATES = ["JEO.md", "AGENTS.md", ".jeo/context.md", "CLAUDE.md"];
+export const AGENT_GUIDANCE_DIRS = [".agents/rules", ".jeo/rules", ".agents/hooks", ".jeo/hooks"] as const;
+const PER_CONTEXT_FILE_CHARS = 16_000;
+const TOTAL_CONTEXT_CHARS = 64_000;
+const BASE_CONTEXT_CHARS = 48_000;
+const GUIDANCE_CONTEXT_CHARS = TOTAL_CONTEXT_CHARS - BASE_CONTEXT_CHARS;
+const MAX_AGENT_GUIDANCE_FILES = 20;
+const AGENT_GUIDANCE_EXTENSIONS = new Set([".md", ".json", ".jsonc", ".yaml", ".yml", ".toml"]);
+
+async function readContextFile(filePath: string, displayPath: string, remainingChars: number): Promise<ProjectContextFile | null> {
+  if (remainingChars <= 0) return null;
+  try {
+    const stat = await fs.stat(filePath);
+    if (!stat.isFile() || stat.size <= 0) return null;
+    const content = await fs.readFile(filePath, "utf-8");
+    if (content.length <= 0) return null;
+    const cap = Math.min(PER_CONTEXT_FILE_CHARS, remainingChars);
+    const finalContent = content.length > cap ? content.slice(0, cap) + "\n…(truncated)" : content;
+    return { path: displayPath.replace(/\\/g, "/"), content: finalContent };
+  } catch {
+    return null;
+  }
+}
+
+async function collectTextFiles(rootDir: string, displayPrefix: string, maxDepth: number, out: Array<{ filePath: string; displayPath: string }>): Promise<void> {
+  if (out.length >= MAX_AGENT_GUIDANCE_FILES || maxDepth < 0) return;
+  let entries: import("node:fs").Dirent[] = [];
+  try { entries = await fs.readdir(rootDir, { withFileTypes: true }); } catch { return; }
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    if (out.length >= MAX_AGENT_GUIDANCE_FILES) return;
+    const filePath = path.join(rootDir, entry.name);
+    const displayPath = `${displayPrefix}/${entry.name}`.replace(/\\/g, "/");
+    if (entry.isDirectory()) {
+      await collectTextFiles(filePath, displayPath, maxDepth - 1, out);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    if (AGENT_GUIDANCE_EXTENSIONS.has(path.extname(entry.name).toLowerCase())) out.push({ filePath, displayPath });
+  }
+}
+
+interface WorkspaceScan {
+  // Nested AGENTS.md found by the downward walk (depth 0..3, skipping IGNORED_DIRS).
+  nested: Array<{ filePath: string; displayPath: string; depth: number }>;
+  // Local (cwd-rooted) guidance files in canonical order: explicit oma-config/triggers
+  // first, then `.agents/rules`, `.jeo/rules`, `.agents/hooks` buckets. Pre-dedupe/cap.
+  localGuidance: Array<{ filePath: string; displayPath: string }>;
+}
+
+// Guidance roots relative to cwd, mirroring AGENT_GUIDANCE_DIRS order. Each is the
+// directory collectTextFiles used to traverse (maxDepth 2).
+const GUIDANCE_ROOTS = AGENT_GUIDANCE_DIRS.map((dir) => ({
+  segs: dir.split("/"),
+  prefix: dir,
+}));
+
+const EXPLICIT_GUIDANCE_FILES = [".agents/oma-config.yaml", ".agents/oma-config.yml", ".agents/hooks/core/triggers.json"];
+
+// Module-level cache of the downward scan, keyed by resolved cwd. The scan is
+// independent of $HOME (it only walks the cwd subtree), so caching by cwd is safe.
+const workspaceScanCache = new Map<string, WorkspaceScan>();
+
+function segsEqual(a: readonly string[], b: readonly string[]): boolean {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
+
+function isStrictPrefix(prefix: readonly string[], full: readonly string[]): boolean {
+  if (prefix.length >= full.length) return false;
+  for (let i = 0; i < prefix.length; i++) if (prefix[i] !== full[i]) return false;
+  return true;
+}
+
+interface GuidanceCtx {
+  bucket: number;
+  prefix: string;
+  remaining: number; // mirrors collectTextFiles maxDepth: root=2, then decremented
+}
+
+// Single downward traversal from resolvedCwd that, in ONE readdir per directory,
+// collects BOTH nested AGENTS.md files and the local `.agents`/`.jeo` guidance files.
+// Replaces the previous separate walkDown + per-root collectTextFiles recursions
+// (which re-read the overlapping `.agents/rules` and `.agents/hooks` subtrees).
+async function scanWorkspaceDownwards(resolvedCwd: string): Promise<WorkspaceScan> {
+  const nested: WorkspaceScan["nested"] = [];
+  const buckets: Array<Array<{ filePath: string; displayPath: string }>> = GUIDANCE_ROOTS.map(() => []);
+
+  async function walk(dir: string, depth: number, relSegs: string[], nestedActive: boolean, guidance: GuidanceCtx | null): Promise<void> {
+    let entries: import("node:fs").Dirent[] = [];
+    try { entries = await fs.readdir(dir, { withFileTypes: true }); } catch { return; }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+
+    for (const entry of entries) {
+      const name = entry.name;
+      const childPath = path.join(dir, name);
+      if (entry.isDirectory()) {
+        const childSegs = [...relSegs, name];
+        let childGuidance: GuidanceCtx | null = null;
+        const rootIdx = GUIDANCE_ROOTS.findIndex((r) => segsEqual(childSegs, r.segs));
+        if (rootIdx >= 0) {
+          childGuidance = { bucket: rootIdx, prefix: GUIDANCE_ROOTS[rootIdx].prefix, remaining: 2 };
+        } else if (guidance && guidance.remaining >= 1) {
+          childGuidance = { bucket: guidance.bucket, prefix: `${guidance.prefix}/${name}`, remaining: guidance.remaining - 1 };
+        }
+        const childNestedActive = nestedActive && !IGNORED_DIRS.includes(name);
+        const childDepth = depth + 1;
+        const nestedWantsDescend = childNestedActive && childDepth <= 3;
+        const guidanceWantsDescend = childGuidance !== null;
+        const ancestorWantsDescend = GUIDANCE_ROOTS.some((r) => isStrictPrefix(childSegs, r.segs));
+        if (nestedWantsDescend || guidanceWantsDescend || ancestorWantsDescend) {
+          await walk(childPath, childDepth, childSegs, childNestedActive, childGuidance);
+        }
+      } else if (entry.isFile()) {
+        if (nestedActive && depth <= 3 && name === "AGENTS.md") {
+          const displayPath = path.relative(resolvedCwd, childPath).replace(/\\/g, "/");
+          nested.push({ filePath: childPath, displayPath, depth });
+        }
+        if (guidance && guidance.remaining >= 0 && AGENT_GUIDANCE_EXTENSIONS.has(path.extname(name).toLowerCase())) {
+          buckets[guidance.bucket].push({ filePath: childPath, displayPath: `${guidance.prefix}/${name}`.replace(/\\/g, "/") });
+        }
+      }
+    }
+  }
+
+  await walk(resolvedCwd, 0, [], true, null);
+
+  // Explicit cwd-rooted guidance files (kept as cheap stat checks, fixed order, first).
+  const explicit: Array<{ filePath: string; displayPath: string }> = [];
+  for (const rel of EXPLICIT_GUIDANCE_FILES) {
+    const filePath = path.join(resolvedCwd, rel);
+    try {
+      const st = await fs.stat(filePath);
+      if (st.isFile() && st.size > 0) explicit.push({ filePath, displayPath: rel.replace(/\\/g, "/") });
+    } catch { /* optional */ }
+  }
+
+  return { nested, localGuidance: [...explicit, ...buckets.flat()] };
+}
+
+async function getWorkspaceScan(cwd: string): Promise<WorkspaceScan> {
+  const resolvedCwd = path.resolve(cwd);
+  const cached = workspaceScanCache.get(resolvedCwd);
+  if (cached) return cached;
+  const scan = await scanWorkspaceDownwards(resolvedCwd);
+  workspaceScanCache.set(resolvedCwd, scan);
+  return scan;
+}
+
+/**
+ * Invalidate the cached single-pass workspace scan. Pass a `cwd` to clear just that
+ * entry (resolved), or omit to clear the entire cache. Call this after the workspace's
+ * AGENTS.md / `.agents` / `.jeo` guidance files change on disk.
+ */
+export function invalidateWorkspaceScan(cwd?: string): void {
+  if (cwd === undefined) {
+    workspaceScanCache.clear();
+    return;
+  }
+  workspaceScanCache.delete(path.resolve(cwd));
+}
+
+export async function discoverAgentGuidanceFiles(cwd = process.cwd()): Promise<Array<{ filePath: string; displayPath: string }>> {
+  const scan = await getWorkspaceScan(cwd);
+  const out: Array<{ filePath: string; displayPath: string }> = [...scan.localGuidance];
+  const home = path.join(process.env.HOME || "", "");
+  const homeRoots = [
+    { rootDir: path.join(home, ".agents", "rules"), displayPrefix: "~/.agents/rules" },
+    { rootDir: path.join(home, ".jeo", "rules"), displayPrefix: "~/.jeo/rules" },
+    { rootDir: path.join(home, ".agents", "hooks"), displayPrefix: "~/.agents/hooks" },
+    { rootDir: path.join(home, ".jeo", "hooks"), displayPrefix: "~/.jeo/hooks" },
+  ];
+  for (const root of homeRoots) {
+    await collectTextFiles(root.rootDir, root.displayPrefix, 2, out);
+  }
+  const seen = new Set<string>();
+  return out.filter(entry => {
+    const key = entry.displayPath.toLowerCase();
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  }).slice(0, MAX_AGENT_GUIDANCE_FILES);
+}
+
 
 export async function loadProjectContext(cwd = process.cwd()): Promise<ProjectContextFile[]> {
   const result: ProjectContextFile[] = [];
+  let baseChars = 0;
+  let guidanceChars = 0;
+  const addGuidanceFile = async (filePath: string, displayPath: string) => {
+    const file = await readContextFile(filePath, displayPath, GUIDANCE_CONTEXT_CHARS - guidanceChars);
+    if (!file) return;
+    result.push(file);
+    guidanceChars += file.content.length;
+  };
 
-  for (const candidate of CONTEXT_CANDIDATES) {
-    const filePath = path.join(cwd, candidate);
-    try {
-      const stat = await fs.stat(filePath);
-      if (stat.isFile() && stat.size > 0) {
-        const content = await fs.readFile(filePath, "utf-8");
-        if (content.length > 0) {
-          let finalContent = content;
-          if (content.length > 16000) {
-            finalContent = content.slice(0, 16000) + "\n…(truncated)";
-          }
-          result.push({
-            path: candidate,
-            content: finalContent,
+  const resolvedCwd = path.resolve(cwd);
+  const home = process.env.HOME ? path.resolve(process.env.HOME) : null;
+  const collectedItems: ContextItem[] = [];
+
+  // 1. CWD 및 부모 walk
+  let curr = resolvedCwd;
+  let distance = 0;
+  while (true) {
+    if (home && curr === home) {
+      break;
+    }
+
+    for (const candidate of CONTEXT_CANDIDATES) {
+      const filePath = path.join(curr, candidate);
+      try {
+        const stat = await fs.stat(filePath);
+        if (stat.isFile() && stat.size > 0) {
+          const displayPath = path.relative(resolvedCwd, filePath).replace(/\\/g, "/");
+          collectedItems.push({
+            filePath,
+            displayPath: displayPath || candidate,
+            type: distance === 0 ? "cwd" : "parent",
+            distance: distance === 0 ? undefined : distance,
+            candidateName: candidate,
           });
         }
+      } catch {
+        // 무시
+      }
+    }
+
+    let isGitRoot = false;
+    try {
+      const gitStat = await fs.stat(path.join(curr, ".git"));
+      if (gitStat.isDirectory() || gitStat.isFile()) {
+        isGitRoot = true;
+      }
+    } catch {
+      // 무시
+    }
+
+    if (isGitRoot) {
+      break;
+    }
+
+    const parent = path.dirname(curr);
+    if (parent === curr) {
+      break;
+    }
+    curr = parent;
+    distance++;
+  }
+
+  // 2. CWD 하위 중첩 AGENTS.md 수집 (depth <= 3) — 캐시된 단일 스캔에서 읽음
+  const scan = await getWorkspaceScan(resolvedCwd);
+  for (const nf of scan.nested) {
+    collectedItems.push({
+      filePath: nf.filePath,
+      displayPath: nf.displayPath,
+      type: "nested",
+      depth: nf.depth,
+      candidateName: "AGENTS.md",
+    });
+  }
+
+  // 3. 우선순위 정렬
+  const typeOrder = { cwd: 1, nested: 2, parent: 3 };
+  collectedItems.sort((a, b) => {
+    if (a.type !== b.type) {
+      return typeOrder[a.type] - typeOrder[b.type];
+    }
+    if (a.type === "cwd") {
+      return CONTEXT_CANDIDATES.indexOf(a.candidateName) - CONTEXT_CANDIDATES.indexOf(b.candidateName);
+    } else if (a.type === "nested") {
+      if (a.depth !== b.depth) {
+        return (b.depth ?? 0) - (a.depth ?? 0);
+      }
+      return a.displayPath.localeCompare(b.displayPath);
+    } else {
+      if (a.distance !== b.distance) {
+        return (a.distance ?? 0) - (b.distance ?? 0);
       }
-    } catch (err) {
-      // Skip missing, unreadable, or directories/empty files
+      return CONTEXT_CANDIDATES.indexOf(a.candidateName) - CONTEXT_CANDIDATES.indexOf(b.candidateName);
     }
+  });
+
+  // 중복 경로 제거 (Set 사용)
+  const seenPaths = new Set<string>();
+  const uniqueItems: ContextItem[] = [];
+  for (const item of collectedItems) {
+    const key = path.resolve(item.filePath);
+    if (!seenPaths.has(key)) {
+      seenPaths.add(key);
+      uniqueItems.push(item);
+    }
+  }
+
+  // 4. 예산 내에서 로드
+  for (const item of uniqueItems) {
+    if (baseChars >= BASE_CONTEXT_CHARS) {
+      break;
+    }
+    const file = await readContextFile(item.filePath, item.displayPath, BASE_CONTEXT_CHARS - baseChars);
+    if (!file) continue;
+    result.push(file);
+    baseChars += file.content.length;
+  }
+
+  // GJC/OMA parity: skill docs are loaded by `skills/catalog.ts`; hook/rule guidance is
+  // separate project policy. Keep a reserved guidance budget so large root context files do
+  // not completely crowd out `.agents` / `.jeo` rules and hooks.
+  for (const entry of await discoverAgentGuidanceFiles(cwd)) {
+    await addGuidanceFile(entry.filePath, entry.displayPath);
+    if (guidanceChars >= GUIDANCE_CONTEXT_CHARS) break;
   }
 
   return result;

package/src/agent/dev/AGENTS.md

@@ -0,0 +1,36 @@
+<!-- Parent: ../../AGENTS.md -->
+<!-- Generated: 2026-06-11 | Updated: 2026-06-11 -->
+
+# dev
+
+## Purpose
+Developer-specific agent tooling and spec automation.
+
+## Key Files
+| File | Description |
+|------|-------------|
+| `spec-automation.ts` | Tools to sync `.specify/` artifacts to ooo seeds |
+
+## Subdirectories
+*(None)*
+
+## For AI Agents
+
+### Working In This Directory
+- Tools here are for internal workflow automation rather than core end-user features.
+
+### Testing Requirements
+- Mock filesystem operations.
+
+### Common Patterns
+*(None)*
+
+## Dependencies
+
+### Internal
+- `src/agent/` state management.
+
+### External
+*(None)*
+
+<!-- MANUAL: -->

package/src/agent/dev/advanced-analyzer.ts

@@ -0,0 +1,12 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { isDevMode } from "../state";
+
+export async function runAdvancedAnalysis(cwd: string): Promise<string> {
+  if (!isDevMode()) throw new Error("Advanced analysis only available in Dev Mode");
+
+  console.log("[jeo-Core] Running Advanced Architectural Analysis...");
+  
+  // This will eventually call an LLM to scan the repo
+  return "Advanced Analysis Result: Found tight coupling between src/ai/model-manager.ts and src/ai/providers/. Recommend implementing a Provider Registry pattern.";
+}

package/src/agent/dev/evolution-bridge.ts

@@ -0,0 +1,82 @@
+import { runGjcCommand } from "../../commands/gjc";
+import { runAdvancedAnalysis } from "./advanced-analyzer";
+import { logEvolution } from "./evolution-logger";
+
+export async function consultGjcForAdvancedEvolution(cwd: string) {
+  const report = await runAdvancedAnalysis(cwd);
+  const timestamp = new Date().toISOString();
+  
+  await logEvolution({
+    timestamp,
+    target: "src/ai/model-manager.ts",
+    request: report,
+    status: "in_progress"
+  }, cwd);
+
+  console.log();
+  console.log("[jeo-Core] Architectural Debt identified: Provider Coupling.");
+
+  const request = `
+I am jeo, the Core Engine. My Advanced Analyzer identified tight coupling between 'src/ai/model-manager.ts' and specific provider files.
+Report: ${report}
+
+As my implementation guide (gjc), please:
+1. Design a 'Provider Registry' pattern in 'src/ai/provider-registry.ts'.
+2. Provide a refactoring plan for 'src/ai/model-manager.ts' to use this registry for dynamic provider loading.
+3. Ensure no breaking changes to the external ModelManager API.
+  `;
+
+  try {
+    await runGjcCommand([request]);
+    
+    await logEvolution({
+      timestamp: new Date().toISOString(),
+      target: "src/ai/model-manager.ts",
+      request,
+      status: "success"
+    }, cwd);
+    console.log("[jeo-Core] Advanced Provider Registry refactor SUCCESSFUL.");
+  } catch (err: any) {
+    await logEvolution({
+      timestamp: new Date().toISOString(),
+      target: "src/ai/model-manager.ts",
+      request,
+      status: "failed",
+      verificationOutput: err.message
+    }, cwd);
+    throw err;
+  }
+}
+
+export async function consultGjcForEvolution(cwd: string) {
+  const { runSelfAnalysis } = await import("./self-analysis");
+  const report = await runSelfAnalysis(cwd);
+  const timestamp = new Date().toISOString();
+  
+  await logEvolution({
+    timestamp,
+    target: "src/agent/engine.ts",
+    request: report,
+    status: "in_progress"
+  }, cwd);
+
+  console.log();
+  try {
+    await runGjcCommand([report]);
+    await logEvolution({
+      timestamp: new Date().toISOString(),
+      target: "src/agent/engine.ts",
+      request: report,
+      status: "success"
+    }, cwd);
+  } catch (err: any) {
+    await logEvolution({
+      timestamp: new Date().toISOString(),
+      target: "src/agent/engine.ts",
+      request: report,
+      status: "failed",
+      verificationOutput: err.message
+    }, cwd);
+    throw err;
+  }
+}

package/src/agent/dev/evolution-logger.ts

@@ -0,0 +1,41 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+export interface EvolutionEntry {
+  timestamp: string;
+  target: string;
+  request: string;
+  status: "success" | "failed" | "in_progress";
+  verificationOutput?: string;
+  driftScore?: number;
+  logFile?: string;
+  stage?: "analysis" | "consultation" | "implementation" | "verification";
+}
+
+export async function logEvolution(entry: EvolutionEntry, cwd: string = process.cwd()) {
+  const logPath = path.join(cwd, "logs", "evolution-log.json");
+  await fs.mkdir(path.dirname(logPath), { recursive: true });
+  
+  let logs: EvolutionEntry[] = [];
+  try {
+    const content = await fs.readFile(logPath, "utf-8");
+    logs = JSON.parse(content);
+  } catch {}
+  
+  const existingIdx = logs.findIndex(l => l.status === "in_progress" && l.target === entry.target);
+  if (existingIdx !== -1) {
+    logs[existingIdx] = { ...logs[existingIdx], ...entry };
+  } else {
+    logs.push(entry);
+  }
+  
+  await fs.writeFile(logPath, JSON.stringify(logs, null, 2), "utf-8");
+}
+
+export async function streamEvolutionLogs(executionId: string, output: string, cwd: string = process.cwd()) {
+  const logDir = path.join(cwd, "logs", "evolution");
+  await fs.mkdir(logDir, { recursive: true });
+  const logFile = path.join(logDir, `${executionId}.log`);
+  await fs.appendFile(logFile, output + "\n", "utf-8");
+  return logFile;
+}

package/src/agent/dev/self-analysis.ts

@@ -0,0 +1,64 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { isDevMode } from "../state";
+import type { PerfMetric } from "../output-util";
+
+/**
+ * jeo-Centric Analysis: jeo looks at its own performance and engine.
+ */
+export async function runSelfAnalysis(cwd: string): Promise<string> {
+  if (!isDevMode()) throw new Error("Self-analysis only available in Dev Mode");
+
+  const perfPath = path.join(cwd, ".jeo/state/performance-metrics.json");
+  let perfData: PerfMetric[] = [];
+  try {
+    const content = await fs.readFile(perfPath, "utf-8");
+    perfData = JSON.parse(content);
+  } catch {
+    // If no metrics yet, proceed with engine analysis
+  }
+
+  const targetPath = path.join(cwd, "src/agent/engine.ts");
+  const content = await fs.readFile(targetPath, "utf-8");
+  
+  const lineCount = content.split("\n").length;
+  const hasTooManyResponsibilities = content.includes("runAgentLoop") && content.includes("truncateToolOutput") && content.includes("spillToolResult");
+
+  let report = "Analysis of src/agent/engine.ts:\n";
+  report += "- File length: " + lineCount + " lines.\n";
+  if (lineCount > 300) report += "- Issue: The file is becoming monolithic.\n";
+  if (hasTooManyResponsibilities) report += "- Issue: runAgentLoop handles tool output truncation and spilling directly, which should be modularized.\n";
+  
+  if (perfData.length > 0) {
+    const recent = perfData.slice(-50);
+    const avgDuration = recent.reduce((sum, m) => sum + (m as any).duration, 0) / recent.length;
+    const failures = recent.filter((m) => !m.success).length;
+    
+    report += "\nPerformance & Error Analysis (last " + recent.length + " tools):\n";
+    report += "- Average tool duration: " + avgDuration.toFixed(2) + "ms\n";
+    report += "- Success rate: " + (((recent.length - failures) / recent.length) * 100).toFixed(1) + "%\n";
+    
+    const slowTools = recent.filter((m) => (m as any).duration > 2000);
+    if (slowTools.length > 0) {
+      report += "- Notice: " + slowTools.length + " tools took > 2s. Slowest: " + slowTools.sort((a, b) => (b as any).duration - (a as any).duration)[0].tool + "\n";
+    }
+
+    const recentErrors = recent.filter(m => !m.success && (m as any).error).map(m => (m as any).error!);
+    if (recentErrors.length > 0) {
+      report += "- Top Error Patterns:\n";
+      const counts: Record<string, number> = {};
+      for (const err of recentErrors) {
+        const key = err.substring(0, 60);
+        counts[key] = (counts[key] || 0) + 1;
+      }
+      Object.entries(counts)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 3)
+        .forEach(([err, count]) => {
+          report += "  * [" + count + "x] " + err + "...\n";
+        });
+    }
+  }
+
+  return report;
+}

package/src/agent/dev/self-improve.ts

@@ -0,0 +1,24 @@
+import { isDevMode } from "../state";
+import { runSelfAnalysis } from "./self-analysis";
+import { logEvolution } from "./evolution-logger";
+
+/**
+ * Logic for the agent to analyze its own performance and suggest improvements.
+ * This module is only active when isDevMode() is true.
+ */
+export async function suggestSelfImprovement(cwd: string) {
+  if (!isDevMode()) return null;
+  
+  console.log("[DEV] Analyzing jeo for self-improvement...");
+  const report = await runSelfAnalysis(cwd);
+  
+  await logEvolution({
+    timestamp: new Date().toISOString(),
+    target: "Self-Improvement Audit",
+    request: "Autonomous performance and architectural audit",
+    status: "success",
+    verificationOutput: report
+  });
+  
+  return report;
+}

package/src/agent/dev/spec-automation.ts

@@ -0,0 +1,49 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { logEvolution } from "./evolution-logger";
+
+/**
+ * Level 3: Specification Automation
+ * Syncs .specify/ artifacts to ooo seeds.
+ */
+export async function syncSpecificationToSeed(cwd: string) {
+  const specPath = path.join(cwd, ".specify", "specification.md");
+  const seedPath = path.join(cwd, ".ouroboros", "seeds", "generated-seed.yaml");
+  
+  console.log("[jeo-Core] Syncing specification to ooo seed...");
+  
+  try {
+    const spec = await fs.readFile(specPath, "utf-8");
+    
+    // Simple extraction logic for demo/Phase 3
+    const goalsMatch = spec.match(/## Purpose\n([\s\S]+?)\n\n/);
+    const goals = goalsMatch ? goalsMatch[1].trim() : "Autonomous Evolution";
+    const reqsMatch = spec.match(/## Requirements\n([\s\S]+?)\n\n/);
+    const reqs = reqsMatch ? reqsMatch[1].split("\n").map(l => l.replace(/^[*-]\d+./, "").trim()).filter(Boolean) : [];
+
+    const seedContent = `
+goal: "${goals.replace(/"/g, '\\\\\\\\"')}"
+constraints:
+  - "Bun runtime"
+  - "Zero native dependencies"
+acceptance_criteria:
+${reqs.map(r => `  - "${r.replace(/"/g, '\\\\\\\\"')}"`).join("\n")}
+  - "Mechanical verification (tests) must pass"
+`;
+
+    await fs.mkdir(path.dirname(seedPath), { recursive: true });
+    await fs.writeFile(seedPath, seedContent.trim(), "utf-8");
+    
+    await logEvolution({
+      timestamp: new Date().toISOString(),
+      target: ".ouroboros/seeds/generated-seed.yaml",
+      request: "Automated seed generation from .specify/specification.md",
+      status: "success"
+    });
+    
+    console.log("[jeo-Core] Successfully generated seed.");
+  } catch (err: any) {
+    console.error(`[jeo-Core] Failed to sync specification: ${err.message}`);
+    throw err;
+  }
+}