jeo-code 0.1.0 → 0.4.5

package/src/agent/output-util.ts

@@ -0,0 +1,64 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+export const TOOL_SPILL_THRESHOLD = 32_000;
+
+export function truncateToolOutput(output: string, limit = 8000): string {
+  if (output.length <= limit) return output;
+  const half = Math.floor(limit / 2);
+  return output.slice(0, half) + "\n\n... (elided " + (output.length - limit) + " chars) ...\n\n" + output.slice(-half);
+}
+
+export async function spillToolResult(tool: string, output: string, cwd: string): Promise<string> {
+  const artifactsDir = path.join(cwd, ".jeo", "artifacts");
+  await fs.mkdir(artifactsDir, { recursive: true });
+
+  const ts = new Date().toISOString().replace(/[:.]/g, "-");
+  const filename = "result-" + tool + "-" + ts + ".txt";
+  const fullPath = path.join(artifactsDir, filename);
+
+  await fs.writeFile(fullPath, output, "utf-8");
+  return path.relative(cwd, fullPath);
+}
+
+/** One tool execution's performance record (consumed by dev self-analysis). */
+export interface PerfMetric {
+  tool: string;
+  duration: number;
+  success: boolean;
+  error?: string;
+}
+
+/** Append a tool performance metric to `.jeo/state/performance-metrics.json`
+ *  (bounded to the most recent 200 records). Best-effort: failures are ignored
+ *  so metrics can never break an agent turn. */
+export async function logPerformanceMetric(cwd: string, metric: PerfMetric): Promise<void> {
+  try {
+    const dir = path.join(cwd, ".jeo", "state");
+    const file = path.join(dir, "performance-metrics.json");
+    await fs.mkdir(dir, { recursive: true });
+    let records: PerfMetric[] = [];
+    try {
+      const parsed = JSON.parse(await fs.readFile(file, "utf-8"));
+      if (Array.isArray(parsed)) records = parsed;
+    } catch { /* first write or corrupt file → start fresh */ }
+    records.push(metric);
+    if (records.length > 200) records = records.slice(-200);
+    await fs.writeFile(file, JSON.stringify(records), "utf-8");
+  } catch { /* best-effort */ }
+}
+
+/** Read spec-kit project context (`.specify/memory/constitution.md`) when the repo
+ *  was initialized with GitHub spec-kit, so the agent honors the project
+ *  constitution. Returns null when absent/unreadable; content is capped. */
+export async function loadSpecKitContext(cwd: string): Promise<string | null> {
+  try {
+    const file = path.join(cwd, ".specify", "memory", "constitution.md");
+    const content = (await fs.readFile(file, "utf-8")).trim();
+    if (!content) return null;
+    const capped = content.length > 4000 ? content.slice(0, 4000) + "…" : content;
+    return "\n\n<spec-kit-constitution>\n" + capped + "\n</spec-kit-constitution>";
+  } catch {
+    return null;
+  }
+}

package/src/agent/plan.ts

@@ -0,0 +1,187 @@
+/**
+ * Shared plan-document schema + minimal YAML parser for jeo workflow plans.
+ * Used by both `jeo team` (execution) and `jeo ralplan` (plan generation/validation).
+ */
+import { z } from "zod";
+
+/** Dependency-shaped keys the SERIAL executor cannot honor: `jeo team` runs steps
+ *  in array order, so a plan that EXPRESSES ordering constraints must fail loudly
+ *  instead of silently creating the illusion they are enforced (round-10 LOW). */
+const UNSUPPORTED_DEP_KEYS = ["depends_on", "dependsOn", "after", "needs", "requires", "dependencies"] as const;
+
+export const StepSchema = z.object({
+  name: z.string(),
+  /** Optional subagent role for this step (executor/planner/architect/critic). */
+  role: z.string().optional(),
+}).passthrough().superRefine((step, ctx) => {
+  for (const key of UNSUPPORTED_DEP_KEYS) {
+    if (key in step) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `step "${String((step as Record<string, unknown>).name ?? "?")}" declares "${key}", but jeo team executes steps strictly in array order and does NOT honor dependency metadata — reorder the steps array instead and remove "${key}".`,
+      });
+    }
+  }
+});
+
+export const PlanSchema = z.object({
+  name: z.string().optional(),
+  steps: z.array(StepSchema).min(1),
+}).passthrough();
+
+/**
+ * Tolerate common planning-model deviations so a valid-enough plan still executes:
+ * a top-level list of tasks, a `tasks:` alias for `steps:`, bare-string tasks, and
+ * step name under `task`/`title`/`description`/`step`.
+ */
+export function normalizePlanShape(raw: any): any {
+  let plan = raw;
+  if (Array.isArray(plan)) plan = { steps: plan };
+  if (plan && typeof plan === "object" && !Array.isArray(plan)) {
+    if (!Array.isArray(plan.steps) && Array.isArray(plan.tasks)) plan = { ...plan, steps: plan.tasks };
+    if (Array.isArray(plan.steps)) {
+      plan = {
+        ...plan,
+        steps: plan.steps.map((s: any) =>
+          typeof s === "string"
+            ? { name: s }
+            : s && typeof s === "object" && !s.name
+              ? { ...s, name: s.task ?? s.title ?? s.description ?? s.step ?? "" }
+              : s,
+        ).filter((s: any) => s && typeof s.name === "string" && s.name.trim() !== ""),
+      };
+    }
+  }
+  return plan;
+}
+
+function parseValue(v: string): any {
+  if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) {
+    return v.slice(1, -1);
+  }
+  if (v === "true") return true;
+  if (v === "false") return false;
+  if (v === "null") return null;
+  if (v === "") return "";
+  if (/^-?\d+(\.\d+)?$/.test(v)) return Number(v);
+  return v;
+}
+
+export function parseYaml(yamlStr: string): any {
+  const lines = yamlStr.split(/\r?\n/).map(line => {
+    const commentIdx = line.indexOf('#');
+    const cleanLine = commentIdx !== -1 ? line.slice(0, commentIdx) : line;
+    return {
+      trimmed: cleanLine.trim(),
+      indent: cleanLine.length - cleanLine.trimStart().length
+    };
+  }).filter(l => l.trimmed !== '');
+
+  let idx = 0;
+
+  function parseBlock(baseIndent: number): any {
+    let result: any = null;
+    let isArray = false;
+
+    if (idx < lines.length) {
+      if (lines[idx].trimmed.startsWith('-')) {
+        isArray = true;
+        result = [];
+      } else {
+        result = {};
+      }
+    }
+
+    while (idx < lines.length) {
+      const line = lines[idx];
+      if (line.indent < baseIndent) {
+        break;
+      }
+
+      if (isArray) {
+        if (!line.trimmed.startsWith('-')) {
+          if (result.length > 0 && typeof result[result.length - 1] === 'object') {
+            const colonIdx = line.trimmed.indexOf(':');
+            if (colonIdx !== -1) {
+              const k = line.trimmed.slice(0, colonIdx).trim();
+              const rawVal = line.trimmed.slice(colonIdx + 1).trim();
+              if (rawVal === '') {
+                idx++;
+                result[result.length - 1][k] = parseBlock(line.indent + 1);
+                continue;
+              } else {
+                result[result.length - 1][k] = parseValue(rawVal);
+              }
+            } else {
+              throw new Error(`Invalid line inside array block: "${line.trimmed}"`);
+            }
+          } else {
+            throw new Error(`Invalid line in array: "${line.trimmed}"`);
+          }
+          idx++;
+          continue;
+        }
+
+        const rest = line.trimmed.slice(1).trim();
+        if (rest === '') {
+          idx++;
+          const nested = parseBlock(line.indent + 1);
+          result.push(nested);
+        } else if (rest.includes(':')) {
+          const colonIdx = rest.indexOf(':');
+          const k = rest.slice(0, colonIdx).trim();
+          const rawVal = rest.slice(colonIdx + 1).trim();
+          if (rawVal === '') {
+            idx++;
+            const nestedObj = { [k]: parseBlock(line.indent + 2) };
+            result.push(nestedObj);
+          } else {
+            const item: any = { [k]: parseValue(rawVal) };
+            result.push(item);
+            idx++;
+            while (idx < lines.length && !lines[idx].trimmed.startsWith('-') && lines[idx].indent >= line.indent + 2) {
+              const subLine = lines[idx];
+              const subColonIdx = subLine.trimmed.indexOf(':');
+              if (subColonIdx !== -1) {
+                const subK = subLine.trimmed.slice(0, subColonIdx).trim();
+                const rawSubVal = subLine.trimmed.slice(subColonIdx + 1).trim();
+                if (rawSubVal === '') {
+                  idx++;
+                  item[subK] = parseBlock(subLine.indent + 1);
+                } else {
+                  item[subK] = parseValue(rawSubVal);
+                  idx++;
+                }
+              } else {
+                throw new Error(`Invalid sub-line in block mapping: "${subLine.trimmed}"`);
+              }
+            }
+          }
+        } else {
+          result.push(parseValue(rest));
+          idx++;
+        }
+      } else {
+        const colonIdx = line.trimmed.indexOf(':');
+        if (colonIdx === -1) {
+          throw new Error(`Invalid line: "${line.trimmed}"`);
+        }
+
+        const k = line.trimmed.slice(0, colonIdx).trim();
+        const rawVal = line.trimmed.slice(colonIdx + 1).trim();
+
+        if (rawVal === '') {
+          idx++;
+          result[k] = parseBlock(line.indent + 1);
+        } else {
+          result[k] = parseValue(rawVal);
+          idx++;
+        }
+      }
+    }
+
+    return result;
+  }
+
+  return parseBlock(0);
+}

package/src/agent/seed.ts

@@ -0,0 +1,52 @@
+/**
+ * Shared seed-document helpers (round-12, architect ref 8-Round10Planning #5).
+ *
+ * The deep-interview WRITER and the ultragoal READER of seed lists used to live
+ * in different files with different rules — the writer JSON-encoded each value
+ * while the reader stripped EVERY double quote, so a criterion like
+ * `Display "Done" message` was mangled to `Display \Done\ message` by the time
+ * it reached the verification report. Writer and parser now share one module
+ * and one encoding, and deep-interview asserts the round-trip at freeze time so
+ * any future drift fails loudly instead of corrupting the ledger silently.
+ */
+
+/** Serialize a named YAML list with JSON-encoded scalar items. */
+export function yamlList(name: string, values: string[]): string {
+  if (values.length === 0) return `${name}: []`;
+  return `${name}:\n${values.map(value => `  - ${JSON.stringify(value)}`).join("\n")}`;
+}
+
+/** Parse a named list out of a seed document written by `yamlList` (with a
+ *  lenient fallback for legacy / hand-edited unquoted items). */
+export function parseSeedList(content: string, name: string): string[] {
+  const out: string[] = [];
+  let inList = false;
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith(`${name}:`)) {
+      inList = true;
+      continue;
+    }
+    if (!inList) continue;
+    if (trimmed.startsWith("- ")) {
+      const rawValue = trimmed.replace(/^-\s*/, "");
+      if (rawValue.startsWith('"')) {
+        try {
+          out.push(JSON.parse(rawValue) as string);
+          continue;
+        } catch { /* not a clean JSON string — fall through to the lenient path */ }
+      }
+      // Legacy/hand-written item: strip only a MATCHED outer quote pair, never
+      // interior quotes (the old reader's replace(/"/g,"") mangled those).
+      out.push(rawValue.replace(/^"(.*)"$/, "$1").replace(/^'(.*)'$/, "$1").trim());
+    } else if (trimmed === "" || /^[A-Za-z_][\w-]*:/.test(trimmed)) {
+      inList = false; // blank line or next section header ends the list
+    }
+  }
+  return out.filter(v => v.length > 0);
+}
+
+/** The acceptance-criteria list ultragoal verifies against. */
+export function parseSeedAcceptanceCriteria(content: string): string[] {
+  return parseSeedList(content, "acceptance_criteria");
+}

package/src/agent/session.ts

@@ -1,5 +1,5 @@
 import type { Message } from "./loop";
-import { getLocalJocDir } from "./state";
+import { getLocalJeoDir } from "./state";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 
@@ -9,6 +9,7 @@ export interface SessionHeader {
   id: string;
   timestamp: string;
   cwd: string;
+  title?: string;
 }
 
 export interface SessionEntry {
@@ -17,6 +18,13 @@ export interface SessionEntry {
   message: Message;
 }
 
+export interface CompactionEntry {
+  type: "compaction";
+  timestamp: string;
+  seq: number;
+  summary: string;
+  replacesThrough: number;
+}
 export interface SessionSummary {
   id: string;
   timestamp: string;
@@ -24,6 +32,7 @@ export interface SessionSummary {
   messageCount: number;
   preview: string;
   mtimeMs?: number;
+  title?: string;
 }
 
 export const SESSION_VERSION = 1;
@@ -33,7 +42,7 @@ export function newSessionId(): string {
 }
 
 export function sessionsDir(cwd = process.cwd()): string {
-  return path.join(getLocalJocDir(cwd), "sessions");
+  return path.join(getLocalJeoDir(cwd), "sessions");
 }
 
 export function sessionPath(id: string, cwd = process.cwd()): string {
@@ -76,6 +85,41 @@ export async function appendMessage(
   await fs.appendFile(file, JSON.stringify(entry) + "\n", "utf8");
 }
 
+/** Append a batch of messages with ONE fs append (turn-end persistence: a long
+ *  turn previously issued one sequential appendFile per intermediate message). */
+export async function appendMessages(
+  id: string,
+  messages: readonly Message[],
+  cwd = process.cwd()
+): Promise<void> {
+  if (messages.length === 0) return;
+  const file = sessionPath(id, cwd);
+  const timestamp = new Date().toISOString();
+  const chunk = messages
+    .map(message => JSON.stringify({ type: "message", timestamp, message } satisfies SessionEntry))
+    .join("\n") + "\n";
+  await fs.appendFile(file, chunk, "utf8");
+}
+
+export async function appendCompaction(
+  id: string,
+  seq: number,
+  summary: string,
+  replacesThrough: number,
+  cwd = process.cwd()
+): Promise<void> {
+  const file = sessionPath(id, cwd);
+  const entry: CompactionEntry = {
+    type: "compaction",
+    timestamp: new Date().toISOString(),
+    seq,
+    summary,
+    replacesThrough,
+  };
+
+  await fs.appendFile(file, JSON.stringify(entry) + "\n", "utf8");
+}
+
 export async function loadSession(
   id: string,
   cwd = process.cwd()
@@ -93,7 +137,8 @@ export async function loadSession(
 
   const lines = content.split("\n");
   let header: SessionHeader | undefined;
-  const messages: Message[] = [];
+  const rawMessages: Message[] = [];
+  const compactions: CompactionEntry[] = [];
 
   for (const line of lines) {
     if (!line.trim()) continue;
@@ -103,7 +148,9 @@ export async function loadSession(
         if (entry.type === "session" && !header) {
           header = entry as SessionHeader;
         } else if (entry.type === "message") {
-          messages.push(entry.message);
+          rawMessages.push(entry.message);
+        } else if (entry.type === "compaction") {
+          compactions.push(entry as CompactionEntry);
         }
       }
     } catch (err) {
@@ -118,6 +165,23 @@ export async function loadSession(
     throw new Error(`Session header missing in session ${id}`);
   }
 
+  let messages = rawMessages;
+  if (compactions.length > 0) {
+    const lastComp = compactions[compactions.length - 1];
+    const { summary, replacesThrough } = lastComp;
+    
+    const hasSystem = rawMessages.length > 0 && rawMessages[0].role === "system";
+    const systemPrompt = hasSystem ? [rawMessages[0]] : [];
+    
+    const summaryMessage: Message = {
+      role: "user",
+      content: `[Earlier conversation summary]\n${summary}`,
+    };
+    
+    const remaining = rawMessages.slice(replacesThrough + 1);
+    messages = [...systemPrompt, summaryMessage, ...remaining];
+  }
+
   return { header, messages };
 }
 
@@ -143,33 +207,76 @@ export async function listSessions(cwd = process.cwd()): Promise<SessionSummary[
       const content = await fs.readFile(filePath, "utf8");
       const lines = content.split("\n");
       let header: SessionHeader | undefined;
-      let messageCount = 0;
-      let firstUserMessageContent: string | undefined;
 
+      // 1. 헤더만 JSON.parse하여 획득 (가장 첫 valid JSON)
       for (const line of lines) {
         if (!line.trim()) continue;
-        try {
-          const entry = JSON.parse(line);
-          if (entry && typeof entry === "object") {
-            if (entry.type === "session" && !header) {
-              header = entry as SessionHeader;
-            } else if (entry.type === "message") {
+        if (line.includes('"type":"session"')) {
+          try {
+            header = JSON.parse(line);
+            break;
+          } catch {
+            // continue
+          }
+        }
+      }
+
+      if (!header) {
+        continue;
+      }
+
+      // 2. 마지막 compaction 마커 라인을 역순 탐색
+      let lastCompaction: CompactionEntry | undefined;
+      for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i];
+        if (line.includes('"type":"compaction"')) {
+          try {
+            lastCompaction = JSON.parse(line);
+            break;
+          } catch {
+            // continue
+          }
+        }
+      }
+
+      // 3. JSON.parse 오버헤드 최소화하며 카운팅 및 프리뷰 추출
+      let messageCount = 0;
+      let firstUserMessageContent: string | undefined;
+
+      if (lastCompaction) {
+        let msgIndex = 0;
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          if (line.includes('"type":"message"')) {
+            if (msgIndex > lastCompaction.replacesThrough) {
               messageCount++;
-              if (!firstUserMessageContent && entry.message?.role === "user") {
-                firstUserMessageContent = entry.message.content;
-              }
             }
+            msgIndex++;
           }
-        } catch (err) {
-          if (!header) {
-            throw err;
+        }
+        messageCount += 1; // summary message
+      } else {
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          if (line.includes('"type":"message"')) {
+            messageCount++;
           }
-          continue;
         }
       }
 
-      if (!header) {
-        continue;
+      // 4. preview를 위한 첫 user message 추출
+      for (const line of lines) {
+        if (line.includes('"type":"message"') && line.includes('"role":"user"')) {
+          try {
+            const parsed = JSON.parse(line);
+            if (parsed?.message?.content) {
+              firstUserMessageContent = parsed.message.content;
+              break;
+            }
+          } catch {
+            // continue
+          }
+        }
       }
 
       const preview = firstUserMessageContent ? firstUserMessageContent.slice(0, 60) : "";
@@ -181,6 +288,7 @@ export async function listSessions(cwd = process.cwd()): Promise<SessionSummary[
         messageCount,
         preview,
         mtimeMs: stat.mtimeMs,
+        title: header.title,
       });
     } catch {
       // Tolerate malformed files (skip them)
@@ -196,3 +304,109 @@ export async function latestSessionId(cwd = process.cwd()): Promise<string | und
   const list = await listSessions(cwd);
   return list[0]?.id;
 }
+
+/**
+ * Rename a session by updating the title in its JSONL header.
+ * Throws a clear Error if the session file does not exist.
+ */
+export async function renameSession(id: string, title: string, cwd = process.cwd()): Promise<void> {
+  const file = sessionPath(id, cwd);
+  let content: string;
+  try {
+    content = await fs.readFile(file, "utf8");
+  } catch (err: any) {
+    if (err.code === "ENOENT") {
+      throw new Error(`Session ${id} does not exist: ${err.message}`);
+    }
+    throw err;
+  }
+
+  const lines = content.split("\n");
+  let headerIndex = -1;
+  let header: SessionHeader | undefined;
+
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim()) {
+      try {
+        const parsed = JSON.parse(lines[i]);
+        if (parsed && typeof parsed === "object" && parsed.type === "session") {
+          header = parsed as SessionHeader;
+          headerIndex = i;
+          break;
+        }
+      } catch {
+        // tolerate parsing error or check next line
+      }
+    }
+  }
+
+  if (headerIndex === -1 || !header) {
+    throw new Error(`Session header missing in session ${id}`);
+  }
+
+  header.title = title;
+  lines[headerIndex] = JSON.stringify(header);
+  await fs.writeFile(file, lines.join("\n"), "utf8");
+}
+
+/**
+ * Delete a session file.
+ * Returns false on ENOENT, true on success.
+ */
+export async function deleteSession(id: string, cwd = process.cwd()): Promise<boolean> {
+  const file = sessionPath(id, cwd);
+  try {
+    await fs.unlink(file);
+    return true;
+  } catch (err: any) {
+    if (err.code === "ENOENT") {
+      return false;
+    }
+    throw err;
+  }
+}
+
+export interface ExportOptions {
+  /** Include system messages in the export (default false — they're boilerplate). */
+  includeSystem?: boolean;
+}
+
+/**
+ * Render a saved session to Markdown or JSON for handoff, bug reports, and audit
+ * trails. Reuses `loadSession` (which tolerates a malformed trailing line).
+ */
+export async function exportSession(
+  id: string,
+  format: "markdown" | "json" = "markdown",
+  cwd = process.cwd(),
+  opts: ExportOptions = {},
+): Promise<string> {
+  const { header, messages } = await loadSession(id, cwd);
+  const picked = opts.includeSystem ? messages : messages.filter(m => m.role !== "system");
+
+  if (format === "json") {
+    return JSON.stringify(
+      { id: header.id, timestamp: header.timestamp, cwd: header.cwd, messageCount: picked.length, messages: picked },
+      null,
+      2,
+    );
+  }
+
+  const lines: string[] = [
+    `# jeo session ${header.id}`,
+    "",
+    `- Started: ${header.timestamp}`,
+    `- Workspace: ${header.cwd}`,
+    `- Messages: ${picked.length}`,
+    "",
+  ];
+  for (const m of picked) {
+    const role = m.role.charAt(0).toUpperCase() + m.role.slice(1);
+    // Fence longer than the longest backtick run in the body (CommonMark) so message
+    // content containing ``` doesn't prematurely close the code fence.
+    const longest = (m.content.match(/`+/g) ?? []).reduce((mx, r) => Math.max(mx, r.length), 0);
+    const fence = "`".repeat(Math.max(3, longest + 1));
+    lines.push(`## ${role}`, "", fence, m.content, fence, "");
+  }
+  return lines.join("\n");
+}