mini-codex 0.1.0

package/dist/providers/openai.js

@@ -0,0 +1,278 @@
+import { OpenAIOAuthManager } from "../auth/openai-oauth.js";
+import { providerInstructions } from "../prompt.js";
+const MODEL = process.env.MINI_CODEX_MODEL || "gpt-5.4";
+const BASE_URL = "https://chatgpt.com/backend-api/codex/responses";
+const JWT_CLAIM_PATH = "https://api.openai.com/auth";
+const tools = [
+    "list_files",
+    "read_file",
+    "search_files",
+    "write_file",
+    "edit_file",
+    "run_command",
+    "write_memory",
+    "spawn_subagents",
+    "wait_subagents",
+    "finish",
+];
+function toolCallSchema(tool, args, required = []) {
+    return {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            tool: { type: "string", const: tool },
+            args: {
+                type: "object",
+                additionalProperties: false,
+                properties: args,
+                required,
+            },
+        },
+        required: ["tool", "args"],
+    };
+}
+function decodeJwt(token) {
+    try {
+        const parts = token.split(".");
+        if (parts.length !== 3)
+            return null;
+        const payload = parts[1];
+        const normalized = payload.replace(/-/g, "+").replace(/_/g, "/");
+        const padded = normalized + "=".repeat((4 - (normalized.length % 4)) % 4);
+        return JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function extractAccountId(token) {
+    const payload = decodeJwt(token);
+    const accountId = payload?.[JWT_CLAIM_PATH]?.chatgpt_account_id;
+    if (!accountId)
+        throw new Error("Failed to extract ChatGPT account id from access token");
+    return accountId;
+}
+async function parseSSE(response) {
+    const text = await response.text();
+    const chunks = text.split(/\n\n/);
+    const events = [];
+    for (const chunk of chunks) {
+        const dataLines = chunk
+            .split("\n")
+            .filter((line) => line.startsWith("data:"))
+            .map((line) => line.slice(5).trim());
+        if (!dataLines.length)
+            continue;
+        const data = dataLines.join("\n").trim();
+        if (!data || data === "[DONE]")
+            continue;
+        try {
+            events.push(JSON.parse(data));
+        }
+        catch {
+            // ignore malformed event
+        }
+    }
+    for (const event of events) {
+        if (event.type === "response.failed") {
+            throw new Error(event.response?.error?.message || "Codex/OpenAI response failed");
+        }
+        if (event.type === "error") {
+            throw new Error(event.message || event.code || "Codex/OpenAI error event");
+        }
+    }
+    const completed = [...events].reverse().find((event) => event.type === "response.completed" || event.type === "response.done");
+    const outputText = completed?.response?.output_text;
+    if (typeof outputText === "string" && outputText.trim())
+        return outputText;
+    const textDeltas = events
+        .filter((event) => event.type === "response.output_text.delta" && typeof event.delta === "string")
+        .map((event) => event.delta)
+        .join("");
+    return textDeltas;
+}
+export function extractJsonObjects(text) {
+    const values = [];
+    let cursor = 0;
+    while (cursor < text.length) {
+        const start = text.indexOf("{", cursor);
+        if (start < 0)
+            break;
+        let depth = 0;
+        let inString = false;
+        let escaped = false;
+        let end = -1;
+        for (let i = start; i < text.length; i++) {
+            const char = text[i];
+            if (inString) {
+                if (escaped) {
+                    escaped = false;
+                }
+                else if (char === "\\") {
+                    escaped = true;
+                }
+                else if (char === "\"") {
+                    inString = false;
+                }
+                continue;
+            }
+            if (char === "\"") {
+                inString = true;
+                continue;
+            }
+            if (char === "{")
+                depth++;
+            if (char === "}")
+                depth--;
+            if (depth === 0) {
+                end = i + 1;
+                break;
+            }
+        }
+        if (end < 0)
+            break;
+        values.push(text.slice(start, end));
+        cursor = end;
+    }
+    return values;
+}
+export function parseDecision(raw) {
+    const trimmed = raw.trim();
+    const unwrapped = trimmed.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "");
+    const extracted = [...extractJsonObjects(trimmed), ...extractJsonObjects(unwrapped)];
+    const candidates = [trimmed, unwrapped, ...extracted].filter((candidate) => Boolean(candidate));
+    for (const candidate of candidates.reverse()) {
+        try {
+            return JSON.parse(candidate);
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error(`OpenAI OAuth provider returned non-JSON decision text: ${trimmed.slice(0, 500)}`);
+}
+export class OpenAIOAuthProvider {
+    auth = new OpenAIOAuthManager();
+    getModelName() {
+        return MODEL;
+    }
+    async next(session, prompt) {
+        const accessToken = await this.auth.getAccessToken();
+        const accountId = extractAccountId(accessToken);
+        const decisionSchema = {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                rationale: { type: "string" },
+                action: {
+                    anyOf: [
+                        {
+                            type: "object",
+                            additionalProperties: false,
+                            properties: {
+                                type: { type: "string", const: "clarify" },
+                                question: { type: "string" },
+                            },
+                            required: ["type", "question"],
+                        },
+                        {
+                            type: "object",
+                            additionalProperties: false,
+                            properties: {
+                                type: { type: "string", const: "tool" },
+                                toolCall: {
+                                    anyOf: [
+                                        toolCallSchema("list_files", {}),
+                                        toolCallSchema("read_file", { path: { type: "string" } }, ["path"]),
+                                        toolCallSchema("search_files", { query: { type: "string" } }, ["query"]),
+                                        toolCallSchema("write_file", {
+                                            path: { type: "string" },
+                                            content: { type: "string" },
+                                        }, ["path", "content"]),
+                                        toolCallSchema("edit_file", {
+                                            path: { type: "string" },
+                                            oldText: { type: "string" },
+                                            newText: { type: "string" },
+                                        }, ["path", "oldText", "newText"]),
+                                        toolCallSchema("run_command", { command: { type: "string" } }, ["command"]),
+                                        toolCallSchema("write_memory", {
+                                            category: { type: "string" },
+                                            title: { type: "string" },
+                                            content: { type: "string" },
+                                        }, ["category", "title", "content"]),
+                                        toolCallSchema("spawn_subagents", {
+                                            agents: {
+                                                type: "array",
+                                                items: {
+                                                    type: "object",
+                                                    additionalProperties: false,
+                                                    properties: {
+                                                        name: { type: "string" },
+                                                        task: { type: "string" },
+                                                    },
+                                                    required: ["name", "task"],
+                                                },
+                                            },
+                                        }, ["agents"]),
+                                        toolCallSchema("wait_subagents", {}),
+                                        toolCallSchema("finish", {
+                                            answer: { type: "string" },
+                                        }, ["answer"]),
+                                    ],
+                                },
+                            },
+                            required: ["type", "toolCall"],
+                        },
+                    ],
+                },
+            },
+            required: ["rationale", "action"],
+        };
+        const body = {
+            model: MODEL,
+            store: false,
+            stream: true,
+            instructions: providerInstructions(session.depth),
+            input: [
+                {
+                    role: "user",
+                    content: prompt,
+                },
+            ],
+            text: {
+                verbosity: "low",
+                format: {
+                    type: "json_schema",
+                    name: "decision",
+                    schema: decisionSchema,
+                },
+            },
+            tool_choice: "auto",
+            parallel_tool_calls: false,
+        };
+        const headers = new Headers();
+        headers.set("Authorization", `Bearer ${accessToken}`);
+        headers.set("chatgpt-account-id", accountId);
+        headers.set("OpenAI-Beta", "responses=experimental");
+        headers.set("originator", "pi");
+        headers.set("User-Agent", `mini-codex (${process.platform} ${process.arch})`);
+        headers.set("accept", "text/event-stream");
+        headers.set("content-type", "application/json");
+        const response = await fetch(BASE_URL, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            throw new Error(`OpenAI OAuth provider failed: HTTP ${response.status} ${await response.text()}`);
+        }
+        const raw = await parseSSE(response);
+        if (!raw.trim())
+            throw new Error("OpenAI OAuth provider returned no decision text");
+        return {
+            ...parseDecision(raw),
+            model: MODEL,
+            rawResponse: raw,
+        };
+    }
+}

package/dist/providers/test-fixture.d.ts

@@ -0,0 +1,8 @@
+import type { ModelDecision, Session } from "../types.js";
+import type { ModelProvider } from "./base.js";
+export declare class TestFixtureProvider implements ModelProvider {
+    private fixturePromise;
+    private fixture;
+    getModelName(): string;
+    next(session: Session): Promise<ModelDecision>;
+}

package/dist/providers/test-fixture.js

@@ -0,0 +1,36 @@
+import fs from "node:fs/promises";
+async function loadFixture() {
+    const fixturePath = process.env.MINI_CODEX_TEST_FIXTURE;
+    if (!fixturePath) {
+        throw new Error("MINI_CODEX_TEST_FIXTURE is required for the test-fixture provider");
+    }
+    const raw = await fs.readFile(fixturePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed.decisions) || !parsed.decisions.length) {
+        throw new Error("Test fixture must include a non-empty decisions array");
+    }
+    return parsed;
+}
+export class TestFixtureProvider {
+    fixturePromise = null;
+    async fixture() {
+        if (!this.fixturePromise)
+            this.fixturePromise = loadFixture();
+        return this.fixturePromise;
+    }
+    getModelName() {
+        return process.env.MINI_CODEX_TEST_MODEL || "test-fixture-model";
+    }
+    async next(session) {
+        const fixture = await this.fixture();
+        const decision = fixture.decisions[session.steps.length];
+        if (!decision) {
+            throw new Error(`No scripted decision available for step ${session.steps.length + 1}`);
+        }
+        return {
+            ...decision,
+            model: decision.model || fixture.model || this.getModelName(),
+            rawResponse: decision.rawResponse || JSON.stringify(decision),
+        };
+    }
+}

package/dist/runtime.d.ts

@@ -0,0 +1,9 @@
+import type { Session, ToolCall, ToolResult } from "./types.js";
+export declare class AgentRuntime {
+    private readonly session;
+    private readonly subagents;
+    constructor(session: Session);
+    refreshMemory(task: string): Promise<void>;
+    execute(call: ToolCall): Promise<ToolResult>;
+    cleanup(): Promise<void>;
+}

package/dist/runtime.js

@@ -0,0 +1,99 @@
+import { loadProjectMemory, writeProjectMemory } from "./memory.js";
+import { SubagentManager } from "./subagents.js";
+import { runTool as runRepoTool } from "./tools.js";
+function summarizeAgents(agents) {
+    return agents
+        .map((agent) => {
+        const status = `[${agent.status}] ${agent.name}`;
+        if (agent.status === "completed") {
+            return `${status}: ${agent.answer || agent.summary || "completed"}`;
+        }
+        return `${status}: ${agent.error || agent.task}`;
+    })
+        .join("\n");
+}
+export class AgentRuntime {
+    session;
+    subagents;
+    constructor(session) {
+        this.session = session;
+        this.subagents = new SubagentManager(session.repoPath, session.id, session.depth);
+    }
+    async refreshMemory(task) {
+        const memory = await loadProjectMemory(this.session.repoPath, task);
+        this.session.memorySummary = memory.summary;
+        this.session.memoryNotes = memory.relevantNotes;
+    }
+    async execute(call) {
+        switch (call.tool) {
+            case "write_memory": {
+                if (this.session.depth > 0) {
+                    return { ok: false, summary: "Memory writes are only allowed in the main agent", error: "child agent" };
+                }
+                const category = String(call.args.category || "");
+                const title = String(call.args.title || "");
+                const content = String(call.args.content || "");
+                if (!category || !title || !content) {
+                    return { ok: false, summary: "Missing memory args", error: "category, title, and content are required" };
+                }
+                const note = await writeProjectMemory(this.session.repoPath, { category, title, content });
+                await this.refreshMemory(this.session.task);
+                return {
+                    ok: true,
+                    summary: `Saved project memory ${note.title}`,
+                    output: `${note.path}\n${note.preview}`,
+                };
+            }
+            case "spawn_subagents": {
+                const specs = Array.isArray(call.args.agents) ? call.args.agents : [];
+                const normalized = specs
+                    .map((spec) => ({
+                    name: String(spec.name || "").trim(),
+                    task: String(spec.task || "").trim(),
+                }))
+                    .filter((spec) => spec.name && spec.task);
+                if (!normalized.length) {
+                    return { ok: false, summary: "Missing sub-agent specs", error: "agents must include name and task" };
+                }
+                try {
+                    const spawned = await this.subagents.spawn(normalized);
+                    this.session.subagents.push(...spawned);
+                    return {
+                        ok: true,
+                        summary: `Spawned ${spawned.length} sub-agent(s)`,
+                        output: spawned.map((agent) => `${agent.name} -> ${agent.task}`).join("\n"),
+                    };
+                }
+                catch (error) {
+                    return {
+                        ok: false,
+                        summary: "Failed to spawn sub-agents",
+                        error: error instanceof Error ? error.message : String(error),
+                    };
+                }
+            }
+            case "wait_subagents": {
+                const results = await this.subagents.wait();
+                if (!results.length)
+                    return { ok: true, summary: "No active sub-agents" };
+                for (const result of results) {
+                    const index = this.session.subagents.findIndex((agent) => agent.id === result.id);
+                    if (index >= 0)
+                        this.session.subagents[index] = result;
+                    else
+                        this.session.subagents.push(result);
+                }
+                return {
+                    ok: true,
+                    summary: `Collected ${results.length} sub-agent result(s)`,
+                    output: summarizeAgents(results),
+                };
+            }
+            default:
+                return runRepoTool(this.session.repoPath, call);
+        }
+    }
+    async cleanup() {
+        await this.subagents.cleanupAll();
+    }
+}

package/dist/skills.d.ts

@@ -0,0 +1,6 @@
+export interface SelectedSkill {
+    name: string;
+    path: string;
+    content: string;
+}
+export declare function selectSkill(task: string, repoPath: string): Promise<SelectedSkill | null>;

package/dist/skills.js

@@ -0,0 +1,37 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+const SKILL_RULES = [
+    {
+        name: "oauth-provider-development",
+        file: "oauth-provider-development/SKILL.md",
+        keywords: ["oauth", "auth", "token", "provider", "login", "gpt", "openai", "model"],
+    },
+    {
+        name: "testing-and-debugging",
+        file: "testing-and-debugging/SKILL.md",
+        keywords: ["test", "debug", "fix", "failing", "error", "reproduce", "validate"],
+    },
+    {
+        name: "harness-development",
+        file: "harness-development/SKILL.md",
+        keywords: ["loop", "cli", "tool", "runtime", "harness", "report", "edit", "repo"],
+    },
+];
+export async function selectSkill(task, repoPath) {
+    const lower = task.toLowerCase();
+    const match = SKILL_RULES.find((rule) => rule.keywords.some((keyword) => lower.includes(keyword)));
+    if (!match)
+        return null;
+    const skillPath = path.join(repoPath, ".codex", "skills", match.file);
+    try {
+        const content = await fs.readFile(skillPath, "utf8");
+        return {
+            name: match.name,
+            path: skillPath,
+            content,
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/subagents.d.ts

@@ -0,0 +1,16 @@
+import type { SubagentRecord } from "./types.js";
+export declare class SubagentManager {
+    private readonly repoPath;
+    private readonly sessionId;
+    private readonly depth;
+    private active;
+    private rootPathPromise;
+    constructor(repoPath: string, sessionId: string, depth: number);
+    private rootPath;
+    spawn(specs: Array<{
+        name: string;
+        task: string;
+    }>): Promise<SubagentRecord[]>;
+    wait(): Promise<SubagentRecord[]>;
+    cleanupAll(): Promise<void>;
+}