jeo-code 0.1.0 → 0.4.5

package/src/commands/doctor.ts

@@ -1,10 +1,12 @@
 import { readGlobalConfig } from "../agent/state";
 import { resolveCredential, snapshotProvider, type AuthProvider, type Credential } from "../auth";
 import { resolveProvider } from "../ai";
+import { effectiveCredentialForProvider } from "../ai/model-manager";
 import { resolveModelId } from "../ai/model-registry";
 import { meter } from "../tui/components/meter";
 import { size } from "../tui/terminal";
 import chalk from "chalk";
+import { extractChatgptAccountId, CODEX_RESPONSES_URL } from "../ai/providers/openai-responses";
 
 interface ProbeResult {
   status: "ok" | "fail" | "skipped";
@@ -12,7 +14,7 @@ interface ProbeResult {
   latencyMs?: number;
 }
 
-const APP_NAME = "joc";
+const APP_NAME = "jeo";
 const PROBE_TIMEOUT_MS = 4000;
 
 async function timedFetch(url: string, init: RequestInit): Promise<{ res: Response; latencyMs: number }> {
@@ -27,9 +29,40 @@ async function timedFetch(url: string, init: RequestInit): Promise<{ res: Respon
   }
 }
 
+const NO_OPENAI_CREDENTIAL_DETAIL = "no credential (run 'jeo setup' or 'jeo auth login openai')";
+
 async function probeOpenAi(credential: Credential, baseUrl: string | undefined): Promise<ProbeResult> {
+  if (credential.kind === "none" && !baseUrl) {
+    return { status: "skipped", detail: NO_OPENAI_CREDENTIAL_DETAIL };
+  }
+  // ChatGPT/Codex OAuth can't use api.openai.com — verify the Codex backend instead.
+  // A deliberately-unsupported model returns 400 *after* auth but *before* any generation,
+  // so it confirms connectivity + credentials without burning subscription credit.
+  if (credential.kind === "oauth") {
+    const accountId = extractChatgptAccountId(credential.token);
+    const headers: Record<string, string> = {
+      "content-type": "application/json",
+      authorization: `Bearer ${credential.token}`,
+      "OpenAI-Beta": "responses=experimental",
+      originator: "codex_cli_rs",
+      accept: "text/event-stream",
+    };
+    if (accountId) headers["chatgpt-account-id"] = accountId;
+    try {
+      const { res, latencyMs } = await timedFetch(CODEX_RESPONSES_URL, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ model: "jeo-doctor-probe", input: [{ role: "user", content: [{ type: "input_text", text: "ping" }] }], stream: true, store: false }),
+      });
+      if (res.ok || res.status === 400) return { status: "ok", detail: "POST codex/responses (Codex backend reachable)", latencyMs };
+      if (res.status === 401 || res.status === 403) return { status: "fail", detail: `Codex auth rejected (${res.status})`, latencyMs };
+      return { status: "fail", detail: `POST codex/responses ${res.status}`, latencyMs };
+    } catch (err) {
+      return { status: "fail", detail: `network error: ${(err as Error).message}` };
+    }
+  }
   const base = (baseUrl ?? "https://api.openai.com/v1").replace(/\/$/, "");
-  const token = credential.kind === "oauth" || credential.kind === "api_key" ? credential.token : "no-key";
+  const token = credential.kind === "api_key" ? credential.token : "no-key";
   try {
     const { res, latencyMs } = await timedFetch(`${base}/models`, {
       headers: { Authorization: `Bearer ${token}` },
@@ -43,18 +76,31 @@ async function probeOpenAi(credential: Credential, baseUrl: string | undefined):
 
 async function probeGemini(credential: Credential): Promise<ProbeResult> {
   if (credential.kind === "none") {
-    return { status: "skipped", detail: "no credential (run 'joc setup' or 'joc auth login gemini')" };
+    return { status: "skipped", detail: "no credential (run 'jeo setup' or 'jeo auth login gemini')" };
   }
-  const key = credential.kind === "api_key" ? credential.token : "";
-  const url = credential.kind === "oauth"
-    ? "https://generativelanguage.googleapis.com/v1beta/models"
-    : `https://generativelanguage.googleapis.com/v1beta/models?key=${key}`;
+  // OAuth tokens are served via Cloud Code Assist (the REAL call path) — probe
+  // loadCodeAssist there; the public generativelanguage list rejects them.
+  if (credential.kind === "oauth") {
+    const { getGeminiCliHeaders } = await import("../ai/providers/gemini");
+    try {
+      const { res, latencyMs } = await timedFetch("https://cloudcode-pa.googleapis.com/v1internal:loadCodeAssist", {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${credential.token}`,
+          "content-type": "application/json",
+          ...getGeminiCliHeaders(),
+        },
+        body: JSON.stringify({ metadata: { ideType: "IDE_UNSPECIFIED", platform: "PLATFORM_UNSPECIFIED", pluginType: "GEMINI" } }),
+      });
+      if (res.ok) return { status: "ok", detail: "POST cloudcode-pa /v1internal:loadCodeAssist 200 (Cloud Code Assist)", latencyMs };
+      return { status: "fail", detail: `POST cloudcode-pa /v1internal:loadCodeAssist ${res.status}`, latencyMs };
+    } catch (err) {
+      return { status: "fail", detail: `network error: ${(err as Error).message}` };
+    }
+  }
+  const url = `https://generativelanguage.googleapis.com/v1beta/models?key=${credential.token}`;
   try {
-    const { res, latencyMs } = await timedFetch(url, {
-      headers: credential.kind === "oauth"
-        ? { authorization: `Bearer ${credential.token}` }
-        : {},
-    });
+    const { res, latencyMs } = await timedFetch(url, { headers: {} });
     if (res.ok) return { status: "ok", detail: "GET /v1beta/models 200", latencyMs };
     return { status: "fail", detail: `GET /v1beta/models ${res.status}`, latencyMs };
   } catch (err) {
@@ -64,14 +110,12 @@ async function probeGemini(credential: Credential): Promise<ProbeResult> {
 
 async function probeAnthropic(credential: Credential): Promise<ProbeResult> {
   if (credential.kind === "none") {
-    return { status: "skipped", detail: "no credential (run 'joc setup' or 'joc auth login anthropic')" };
-  }
-  // Anthropic has no free model-listing endpoint; verify auth by issuing a
-  // 1-token request that returns quickly without burning meaningful credit.
-  const headers: Record<string, string> = {
-    "content-type": "application/json",
-    "anthropic-version": "2023-06-01",
-  };
+    return { status: "skipped", detail: "no credential (run 'jeo setup' or 'jeo auth login anthropic')" };
+  }
+  // GET /v1/models verifies auth without burning credit and without depending on a
+  // (possibly retired) model id — the old 1-token POST 404'd whenever the probe model
+  // was deprecated.
+  const headers: Record<string, string> = { "anthropic-version": "2023-06-01" };
   if (credential.kind === "oauth") {
     headers.authorization = `Bearer ${credential.token}`;
     headers["anthropic-beta"] = "oauth-2025-04-20";
@@ -79,20 +123,12 @@ async function probeAnthropic(credential: Credential): Promise<ProbeResult> {
     headers["x-api-key"] = credential.token;
   }
   try {
-    const { res, latencyMs } = await timedFetch("https://api.anthropic.com/v1/messages", {
-      method: "POST",
-      headers,
-      body: JSON.stringify({
-        model: "claude-3-5-sonnet-20241022",
-        max_tokens: 1,
-        messages: [{ role: "user", content: "ping" }],
-      }),
-    });
-    if (res.ok) return { status: "ok", detail: "POST /v1/messages 200 (1-token probe)", latencyMs };
+    const { res, latencyMs } = await timedFetch("https://api.anthropic.com/v1/models?limit=1", { headers });
+    if (res.ok) return { status: "ok", detail: "GET /v1/models 200", latencyMs };
     if (res.status === 401 || res.status === 403) {
       return { status: "fail", detail: `auth rejected (${res.status})`, latencyMs };
     }
-    return { status: "fail", detail: `POST /v1/messages ${res.status}`, latencyMs };
+    return { status: "fail", detail: `GET /v1/models ${res.status}`, latencyMs };
   } catch (err) {
     return { status: "fail", detail: `network error: ${(err as Error).message}` };
   }
@@ -139,11 +175,22 @@ export async function runDoctorCommand(args: string[] = []): Promise<void> {
   const cloud = ["anthropic", "openai", "gemini"] as AuthProvider[];
   const cloudProbes = await Promise.all(
     cloud.map(async provider => {
-      const credential = await resolveCredential(provider);
+      const rawCredential = await resolveCredential(provider);
+      let credential = rawCredential;
       let result: ProbeResult;
-      if (provider === "openai") result = await probeOpenAi(credential, config.openaiBaseUrl);
-      else if (provider === "gemini") result = await probeGemini(credential);
-      else result = await probeAnthropic(credential);
+      try {
+        credential = effectiveCredentialForProvider(
+          provider,
+          rawCredential,
+          config,
+          provider === defaultProvider ? config.defaultModel : provider,
+        );
+        if (provider === "openai") result = await probeOpenAi(credential, config.openaiBaseUrl);
+        else if (provider === "gemini") result = await probeGemini(credential);
+        else result = await probeAnthropic(credential);
+      } catch (err) {
+        result = { status: "fail", detail: (err as Error).message };
+      }
       return { name: provider, credKind: credential.kind, result };
     })
   );
@@ -200,7 +247,7 @@ export async function runDoctorCommand(args: string[] = []): Promise<void> {
   console.log("");
   console.log(`Bun runtime:    v${Bun.version}`);
   console.log(`Default model:  ${config.defaultModel}${resolvedModel !== config.defaultModel ? ` → ${resolvedModel}` : ""} → ${defaultProvider}`);
-  console.log(`Config:         ${process.env.HOME}/.joc/config.json`);
+  console.log(`Config:         ${process.env.HOME}/.jeo/config.json`);
   if (config.openaiBaseUrl) console.log(`OpenAI base:    ${config.openaiBaseUrl}`);
   console.log(`Ollama base:    ${ollamaBase}`);
 
@@ -236,7 +283,7 @@ export async function runDoctorCommand(args: string[] = []): Promise<void> {
   } else if (defaultProbe?.result.status === "skipped") {
     console.log(
       `${chalk.red("[NOT READY]")} Default model '${config.defaultModel}' resolves to '${defaultProvider}', ` +
-      `but no credential is configured. Run 'joc setup' or 'joc auth login ${defaultProvider}'.`
+      `but no credential is configured. Run 'jeo setup' or 'jeo auth login ${defaultProvider}'.`
     );
   } else {
     console.log(

package/src/commands/evolve-core.ts

@@ -0,0 +1,18 @@
+import { consultGjcForEvolution } from "../agent/dev/evolution-bridge";
+import chalk from "chalk";
+
+/**
+ * jeo evolve-core: Triggers a self-evolution turn using gjc as a guide.
+ */
+export async function runEvolveCoreCommand(args: string[]): Promise<void> {
+  const cwd = process.cwd();
+  console.log("\n=== " + chalk.bold.magenta("jeo") + " Autonomous Core Evolution ===");
+  
+  try {
+    await consultGjcForEvolution(cwd);
+    console.log("\n" + chalk.green("✔") + " Evolution turn completed.");
+  } catch (err: any) {
+    console.error("\n" + chalk.red("✘") + " Evolution turn failed: " + err.message);
+    process.exit(1);
+  }
+}

package/src/commands/evolve.ts

@@ -114,7 +114,7 @@ function stageModelJson() {
 }
 
 /**
- * Preview the joc "evolution" TUI identity: render the five stages (or one stage
+ * Preview the jeo "evolution" TUI identity: render the five stages (or one stage
  * for a given step) with art, evolution track, and a stage meter. Supports
  * theming, truecolor gradients, ASCII-only fallback, terminal-width fitting,
  * frame-loop animation, and machine-readable `--json` / `--list` output.
@@ -162,6 +162,7 @@ export async function runEvolveCommand(args: string[], opts: EvolveOptions = {})
       color: useColor,
       width: artWidth,
       height: stageHeight(),
+      unicode,
       ...(gradientOn ? { gradient: themeGradient(theme, index), colorLevel } : {}),
     };
 

package/src/commands/export.ts

@@ -0,0 +1,176 @@
+import { exportSession, latestSessionId, loadSession } from "../agent/session";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+export function renderSessionHtml(
+  meta: { id: string; timestamp?: string; [key: string]: any },
+  messages: { role: string; content: string }[]
+): string {
+  const escapeHtml = (text: string): string => {
+    return text
+      .replace(/&/g, "&")
+      .replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;")
+      .replace(/"/g, "&quot;")
+      .replace(/'/g, "&#039;");
+  };
+
+  const messageHtml = messages
+    .map(m => {
+      const roleClass = (m.role === "system" || m.role === "user" || m.role === "assistant") ? m.role : "other";
+      return `  <div class="message ${roleClass}">
+    <div class="role-label">${escapeHtml(m.role)}</div>
+    <pre>${escapeHtml(m.content)}</pre>
+  </div>`;
+    })
+    .join("\n");
+
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Session ${escapeHtml(meta.id)}</title>
+  <style>
+    body {
+      background-color: #121212;
+      color: #e0e0e0;
+      font-family: Consolas, Monaco, "Andale Mono", "Ubuntu Mono", monospace;
+      padding: 24px;
+      margin: 0;
+      line-height: 1.5;
+    }
+    .header {
+      margin-bottom: 24px;
+      border-bottom: 1px solid #333;
+      padding-bottom: 16px;
+    }
+    .header h1 {
+      margin: 0 0 8px 0;
+      font-size: 24px;
+      color: #ffffff;
+    }
+    .header p {
+      margin: 0;
+      font-size: 14px;
+      color: #888888;
+    }
+    .message {
+      margin: 16px 0;
+      padding: 16px;
+      border-radius: 6px;
+      border-left: 4px solid #555;
+    }
+    .message.system {
+      background-color: #1c1c1c;
+      border-left-color: #888888;
+    }
+    .message.user {
+      background-color: #172a3a;
+      border-left-color: #3b82f6;
+    }
+    .message.assistant {
+      background-color: #143224;
+      border-left-color: #10b981;
+    }
+    .role-label {
+      font-weight: bold;
+      text-transform: uppercase;
+      font-size: 12px;
+      margin-bottom: 8px;
+      letter-spacing: 0.5px;
+    }
+    .message.system .role-label {
+      color: #aaaaaa;
+    }
+    .message.user .role-label {
+      color: #60a5fa;
+    }
+    .message.assistant .role-label {
+      color: #34d399;
+    }
+    pre {
+      margin: 0;
+      white-space: pre-wrap;
+      word-break: break-all;
+      font-family: inherit;
+    }
+  </style>
+</head>
+<body>
+  <div class="header">
+    <h1>Session: ${escapeHtml(meta.id)}</h1>
+    ${meta.timestamp ? `<p>Timestamp: ${escapeHtml(meta.timestamp)}</p>` : ""}
+  </div>
+${messageHtml}
+</body>
+</html>`;
+}
+
+/**
+ * `jeo export [id] [--json] [--system] [--html] [--out <path>]` — print a saved session transcript
+ * (Markdown by default; `--json` for structured; `--system` to include system
+ * messages). Defaults to the latest session when no id is given.
+ */
+export async function runExportCommand(args: string[] = []): Promise<void> {
+  const htmlMode = args.includes("--html");
+  const jsonMode = args.includes("--json");
+  const includeSystem = args.includes("--system");
+
+  if (htmlMode && jsonMode) {
+    console.error("Error: --html and --json options are mutually exclusive.");
+    process.exitCode = 1;
+    return;
+  }
+
+  // Parse --out <path>
+  let outPath: string | undefined;
+  const outIdx = args.indexOf("--out");
+  if (outIdx !== -1 && outIdx + 1 < args.length) {
+    outPath = args[outIdx + 1];
+  }
+
+  // Find the session ID: first non-flag argument that is not the value after --out
+  let id: string | undefined;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      continue;
+    }
+    if (outIdx !== -1 && i === outIdx + 1) {
+      continue;
+    }
+    id = arg;
+    break;
+  }
+
+  if (!id) {
+    id = await latestSessionId();
+  }
+
+  if (!id) {
+    console.log("No session to export. Pass a session id or run a session first.");
+    return;
+  }
+
+  if (htmlMode) {
+    try {
+      const { header, messages } = await loadSession(id, process.cwd());
+      const picked = includeSystem ? messages : messages.filter(m => m.role !== "system");
+      const html = renderSessionHtml(header, picked);
+      const resolvedOutPath = outPath
+        ? path.resolve(process.cwd(), outPath)
+        : path.join(process.cwd(), `jeo-session-${id}.html`);
+      await fs.writeFile(resolvedOutPath, html, "utf8");
+      console.log(resolvedOutPath);
+    } catch (err) {
+      console.log(`Could not export session ${id}: ${(err as Error).message}`);
+    }
+  } else {
+    const format: "markdown" | "json" = jsonMode ? "json" : "markdown";
+    try {
+      console.log(await exportSession(id, format, process.cwd(), { includeSystem }));
+    } catch (err) {
+      console.log(`Could not export session ${id}: ${(err as Error).message}`);
+    }
+  }
+}

package/src/commands/gjc.ts

@@ -0,0 +1,52 @@
+import { runAgentLoop, executorSystemPrompt, DEFAULT_TOOLS } from "../agent/engine";
+import { loadSkills, buildSkillTask, getSkillFrom } from "../skills/catalog";
+import { readGlobalConfig, isDevMode } from "../agent/state";
+import { runPostImplementationHooks } from "../agent/hooks";
+
+export async function runGjcCommand(args: string[]): Promise<void> {
+  const intent = args.join(" ").trim();
+  const config = await readGlobalConfig();
+  
+  if (intent.toLowerCase().includes("self-improve") && !isDevMode()) {
+    console.error("Error: Self-improvement tasks are only allowed in JEO_DEV_MODE=1.");
+    process.exit(1);
+  }
+
+  const model = config.defaultModel || "fast";
+  const skills = await loadSkills();
+  const gjcSkill = getSkillFrom(skills, "gjc");
+
+  if (!gjcSkill) {
+    console.error("Error: gjc skill not found.");
+    process.exit(1);
+  }
+
+  // Correct signature: executorSystemPrompt(role?, protocol?, verificationDirective?)
+  const systemPrompt = executorSystemPrompt();
+  const task = buildSkillTask(gjcSkill, intent);
+
+  await runAgentLoop([{ role: "user", content: task }], {
+    cwd: process.cwd(),
+    systemPrompt,
+    model,
+    tools: DEFAULT_TOOLS,
+    maxSteps: 50,
+  });
+
+  console.log("\n[jeo] Verifying implementation...");
+  const verify = await runPostImplementationHooks(process.cwd(), intent);
+  
+  if (!verify.success) {
+    console.error("\n[jeo] Verification FAILED. Auto-repairing...");
+    const repairTask = `Previous implementation failed verification.\nErrors:\n${verify.output}\n\nPlease fix.`;
+    await runAgentLoop([{ role: "user", content: repairTask }], {
+      cwd: process.cwd(),
+      systemPrompt,
+      model,
+      tools: DEFAULT_TOOLS,
+      maxSteps: 30,
+    });
+  } else {
+    console.log("\n[jeo] Verification SUCCESSFUL.");
+  }
+}