@matterailab/orbcode 0.1.3

package/dist/core/agent.js

@@ -0,0 +1,459 @@
+import { execSync } from "node:child_process";
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
+import { AxonClient } from "../api/client.js";
+import { buildSystemPrompt } from "../prompts/system.js";
+import { describeToolCall, executeTool, getActiveTools, getApprovalKind, } from "../tools/index.js";
+import { walkFiles } from "../tools/executors/listFiles.js";
+import { previewFileChange } from "../tools/executors/files.js";
+import { saveSession } from "./sessions.js";
+const MAX_STEPS_PER_TURN = 50;
+const RESULT_PREVIEW_LINES = 6;
+function detectRepo(cwd) {
+    try {
+        const remote = execSync("git config --get remote.origin.url", {
+            cwd,
+            stdio: ["ignore", "pipe", "ignore"],
+        })
+            .toString()
+            .trim();
+        if (remote)
+            return remote;
+    }
+    catch {
+        // not a git repo or no remote
+    }
+    return path.basename(cwd);
+}
+function getGitSummary(cwd) {
+    try {
+        const branch = execSync("git rev-parse --abbrev-ref HEAD", { cwd, stdio: ["ignore", "pipe", "ignore"] })
+            .toString()
+            .trim();
+        const status = execSync("git status --short", { cwd, stdio: ["ignore", "pipe", "ignore"] })
+            .toString()
+            .trimEnd()
+            .split("\n")
+            .slice(0, 20)
+            .join("\n");
+        return `## Git Repository Information\n- Current Branch: ${branch}\n${status ? `\n### Working Tree Changes\n${status}` : "- Working tree clean"}`;
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * The user's message is wrapped in <user_query> tags internally so the TUI can
+ * identify user-authored text when replaying a session. The wrapper is only an
+ * internal marker and must be stripped before the message is sent to the model.
+ */
+function stripUserQueryTags(text) {
+    return text.replace(/<user_query>\n?/g, "").replace(/\n?<\/user_query>/g, "");
+}
+export class Agent {
+    options;
+    client;
+    systemPrompt;
+    messages = [];
+    todos = "";
+    firstMessageSent = false;
+    sessionApproveEdits;
+    sessionApproveCommands = false;
+    abortController;
+    totalCost = 0;
+    title = "";
+    createdAt = new Date().toISOString();
+    taskId;
+    constructor(options) {
+        this.options = options;
+        this.taskId = options.resume?.id ?? randomUUID();
+        if (options.resume) {
+            this.messages = options.resume.messages;
+            this.todos = options.resume.todos;
+            this.totalCost = options.resume.totalCost;
+            this.title = options.resume.title;
+            this.createdAt = options.resume.createdAt;
+            this.firstMessageSent = this.messages.length > 0;
+        }
+        this.sessionApproveEdits = options.autoApproveEdits;
+        this.systemPrompt = buildSystemPrompt(options.cwd);
+        this.client = new AxonClient({
+            token: options.token,
+            modelId: options.modelId,
+            taskId: this.taskId,
+            organizationId: options.organizationId,
+            repo: detectRepo(options.cwd),
+            baseUrl: options.baseUrl,
+        });
+    }
+    setModel(modelId) {
+        this.options.modelId = modelId;
+        this.client = new AxonClient({
+            token: this.options.token,
+            modelId,
+            taskId: this.taskId,
+            organizationId: this.options.organizationId,
+            repo: detectRepo(this.options.cwd),
+            baseUrl: this.options.baseUrl,
+        });
+    }
+    get modelId() {
+        return this.options.modelId;
+    }
+    /** Replace the prompt-derived title with the backend-generated one. */
+    setTitle(title) {
+        this.title = title;
+        this.persist();
+    }
+    /** Update auto-approval behavior mid-session (shift+tab cycling in the TUI). */
+    setApprovalMode(autoApproveEdits, autoApproveSafeCommands) {
+        this.sessionApproveEdits = autoApproveEdits;
+        this.options.autoApproveEdits = autoApproveEdits;
+        this.options.autoApproveSafeCommands = autoApproveSafeCommands;
+        if (!autoApproveSafeCommands)
+            this.sessionApproveCommands = false;
+    }
+    clear() {
+        this.messages = [];
+        this.todos = "";
+        this.firstMessageSent = false;
+        this.totalCost = 0;
+        this.title = "";
+    }
+    /** Write the current conversation to the sessions directory. */
+    persist() {
+        if (this.messages.length === 0)
+            return;
+        try {
+            saveSession({
+                id: this.taskId,
+                cwd: this.options.cwd,
+                model: this.options.modelId,
+                title: this.title,
+                createdAt: this.createdAt,
+                updatedAt: new Date().toISOString(),
+                totalCost: this.totalCost,
+                todos: this.todos,
+                messages: this.messages,
+            });
+        }
+        catch {
+            // persistence is best-effort; never break the session over it
+        }
+    }
+    abort() {
+        this.abortController?.abort();
+    }
+    get isIdle() {
+        return this.abortController === undefined;
+    }
+    buildEnvironmentDetails() {
+        const files = walkFiles(this.options.cwd, true, 200);
+        const git = getGitSummary(this.options.cwd);
+        const now = new Date();
+        const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        const timeZoneOffset = -now.getTimezoneOffset() / 60;
+        const timeZoneOffsetHours = Math.floor(Math.abs(timeZoneOffset));
+        const timeZoneOffsetMinutes = Math.abs(Math.round((Math.abs(timeZoneOffset) - timeZoneOffsetHours) * 60));
+        const timeZoneOffsetStr = `${timeZoneOffset >= 0 ? "+" : "-"}${timeZoneOffsetHours}:${timeZoneOffsetMinutes.toString().padStart(2, "0")}`;
+        return `# Environment Details
+
+## Current Workspace Directory (${this.options.cwd}) Files
+${files.join("\n") || "(empty directory)"}
+${files.length >= 200 ? "\n(File list truncated.)" : ""}
+
+${git}
+
+## Current Time
+Current time in ISO 8601 UTC format: ${now.toISOString()}
+User time zone: ${timeZone}, UTC${timeZoneOffsetStr}`;
+    }
+    /** Conversation history with internal markers stripped, ready for the model. */
+    outgoingMessages() {
+        return this.messages.map((message) => message.role === "user" && typeof message.content === "string"
+            ? { ...message, content: stripUserQueryTags(message.content) }
+            : message);
+    }
+    toolContext() {
+        return {
+            cwd: this.options.cwd,
+            token: this.options.token,
+            getTodos: () => this.todos,
+            setTodos: (todos) => {
+                this.todos = todos;
+                this.options.callbacks.onEvent({ type: "todos", todos });
+            },
+        };
+    }
+    async runTurn(userText) {
+        const { onEvent } = this.options.callbacks;
+        this.abortController = new AbortController();
+        if (!this.title) {
+            this.title = userText.replace(/\s+/g, " ").trim().slice(0, 80);
+        }
+        let userContent = `<user_query>\n${userText}\n</user_query>`;
+        if (!this.firstMessageSent) {
+            userContent = `${this.buildEnvironmentDetails()}\n\n${userContent}`;
+            this.firstMessageSent = true;
+        }
+        this.messages.push({ role: "user", content: userContent });
+        try {
+            for (let step = 0; step < MAX_STEPS_PER_TURN; step++) {
+                const done = await this.runStep();
+                if (done)
+                    break;
+            }
+        }
+        catch (error) {
+            if (error.name === "AbortError" || this.abortController.signal.aborted) {
+                onEvent({ type: "error", message: "Interrupted." });
+                // Keep the conversation consistent: note the interruption for the model.
+                this.messages.push({
+                    role: "user",
+                    content: "System reminder: The user interrupted this response before it finished.",
+                });
+            }
+            else {
+                onEvent({ type: "error", message: error.message });
+            }
+        }
+        finally {
+            this.abortController = undefined;
+            this.persist();
+            onEvent({ type: "turn-end" });
+        }
+    }
+    /** Summarize the conversation so far and replace history with the summary. */
+    async compact() {
+        const { onEvent } = this.options.callbacks;
+        if (this.messages.length === 0) {
+            onEvent({ type: "error", message: "Nothing to compact yet." });
+            onEvent({ type: "turn-end" });
+            return;
+        }
+        this.abortController = new AbortController();
+        const signal = this.abortController.signal;
+        try {
+            const request = [
+                ...this.outgoingMessages(),
+                {
+                    role: "user",
+                    content: "Summarize this conversation so it can replace the full history. Capture the user's goals, decisions made, files created or modified (with paths), important code details, and any remaining next steps. Be thorough but concise. Respond with only the summary.",
+                },
+            ];
+            let summary = "";
+            for await (const chunk of this.client.createMessage(this.systemPrompt, request, [], signal)) {
+                if (signal.aborted)
+                    throw new DOMException("aborted", "AbortError");
+                if (chunk.type === "text") {
+                    summary += chunk.text;
+                    onEvent({ type: "text-delta", text: chunk.text });
+                }
+                else if (chunk.type === "usage") {
+                    this.totalCost += chunk.totalCost ?? 0;
+                    onEvent({
+                        type: "usage",
+                        inputTokens: chunk.inputTokens,
+                        outputTokens: chunk.outputTokens,
+                        cost: chunk.totalCost ?? 0,
+                        totalCost: this.totalCost,
+                    });
+                }
+            }
+            if (summary) {
+                onEvent({ type: "text-done" });
+                this.messages = [
+                    {
+                        role: "user",
+                        content: `# Conversation Summary\n\nThe conversation history was compacted. Summary of everything so far:\n\n${summary}`,
+                    },
+                ];
+            }
+            else {
+                onEvent({ type: "error", message: "Compaction produced no summary; history left unchanged." });
+            }
+        }
+        catch (error) {
+            if (error.name === "AbortError" || signal.aborted) {
+                onEvent({ type: "error", message: "Compaction interrupted; history left unchanged." });
+            }
+            else {
+                onEvent({ type: "error", message: error.message });
+            }
+        }
+        finally {
+            this.abortController = undefined;
+            this.persist();
+            onEvent({ type: "turn-end" });
+        }
+    }
+    /** Run one model request + tool execution round. Returns true when the turn is over. */
+    async runStep() {
+        const { onEvent } = this.options.callbacks;
+        const signal = this.abortController.signal;
+        let assistantText = "";
+        let hadReasoning = false;
+        let reasoningStart = 0;
+        const toolCallsByIndex = new Map();
+        let nextSyntheticIndex = 10000;
+        const stream = this.client.createMessage(this.systemPrompt, this.outgoingMessages(), getActiveTools(), signal);
+        for await (const chunk of stream) {
+            if (signal.aborted)
+                throw new DOMException("aborted", "AbortError");
+            switch (chunk.type) {
+                case "text":
+                    assistantText += chunk.text;
+                    onEvent({ type: "text-delta", text: chunk.text });
+                    break;
+                case "reasoning":
+                    if (!hadReasoning) {
+                        hadReasoning = true;
+                        reasoningStart = Date.now();
+                    }
+                    onEvent({ type: "reasoning-delta", text: chunk.text });
+                    break;
+                case "native_tool_calls":
+                    for (const tc of chunk.toolCalls) {
+                        const index = tc.index ?? nextSyntheticIndex++;
+                        let pending = toolCallsByIndex.get(index);
+                        if (!pending) {
+                            pending = { id: tc.id || `call_${index}_${Date.now()}`, name: "", arguments: "" };
+                            toolCallsByIndex.set(index, pending);
+                        }
+                        if (tc.id)
+                            pending.id = tc.id;
+                        if (tc.function?.name)
+                            pending.name = tc.function.name;
+                        if (tc.function?.arguments)
+                            pending.arguments += tc.function.arguments;
+                    }
+                    break;
+                case "usage":
+                    this.totalCost += chunk.totalCost ?? 0;
+                    onEvent({
+                        type: "usage",
+                        inputTokens: chunk.inputTokens,
+                        outputTokens: chunk.outputTokens,
+                        cost: chunk.totalCost ?? 0,
+                        totalCost: this.totalCost,
+                    });
+                    break;
+            }
+        }
+        if (hadReasoning) {
+            onEvent({ type: "reasoning-done", durationMs: Date.now() - reasoningStart });
+        }
+        if (assistantText) {
+            onEvent({ type: "text-done" });
+        }
+        const toolCalls = [...toolCallsByIndex.entries()].sort(([a], [b]) => a - b).map(([, tc]) => tc);
+        const assistantMessage = {
+            role: "assistant",
+            content: assistantText || null,
+        };
+        if (toolCalls.length > 0) {
+            assistantMessage.tool_calls = toolCalls.map((tc) => ({
+                id: tc.id,
+                type: "function",
+                function: { name: tc.name, arguments: tc.arguments || "{}" },
+            }));
+        }
+        this.messages.push(assistantMessage);
+        if (toolCalls.length === 0) {
+            return true;
+        }
+        let completed = false;
+        for (const toolCall of toolCalls) {
+            const resultText = await this.handleToolCall(toolCall);
+            this.messages.push({ role: "tool", tool_call_id: toolCall.id, content: resultText });
+            if (toolCall.name === "attempt_completion") {
+                completed = true;
+            }
+        }
+        return completed;
+    }
+    async handleToolCall(toolCall) {
+        const { onEvent, requestApproval, requestFollowup } = this.options.callbacks;
+        let args;
+        try {
+            args = toolCall.arguments ? JSON.parse(toolCall.arguments) : {};
+        }
+        catch (error) {
+            const message = `Invalid JSON arguments for ${toolCall.name}: ${error.message}`;
+            onEvent({
+                type: "tool-end",
+                id: toolCall.id,
+                name: toolCall.name,
+                summary: toolCall.name,
+                resultPreview: message,
+                isError: true,
+            });
+            return message;
+        }
+        const summary = describeToolCall(toolCall.name, args);
+        if (toolCall.name === "attempt_completion") {
+            onEvent({ type: "completion", result: String(args.result ?? "") });
+            return "The user has been shown the completion result.";
+        }
+        if (toolCall.name === "ask_followup_question") {
+            const question = String(args.question ?? "");
+            const suggestions = (Array.isArray(args.follow_up) ? args.follow_up : [])
+                .map((s) => ({ text: String(s?.text ?? "") }))
+                .filter((s) => s.text);
+            const answer = await requestFollowup(question, suggestions);
+            return `<answer>\n${answer}\n</answer>`;
+        }
+        onEvent({ type: "tool-start", id: toolCall.id, name: toolCall.name, summary });
+        const approvalKind = getApprovalKind(toolCall.name, args);
+        const diff = approvalKind === "edit" ? previewFileChange(toolCall.name, args, this.options.cwd) : undefined;
+        const isDangerous = toolCall.name === "execute_command" && Boolean(args.isDangerous);
+        let needsApproval = false;
+        if (approvalKind === "edit" && !this.sessionApproveEdits)
+            needsApproval = true;
+        if (approvalKind === "command") {
+            needsApproval = isDangerous || !(this.sessionApproveCommands || this.options.autoApproveSafeCommands);
+        }
+        if (needsApproval) {
+            const decision = await requestApproval({
+                kind: approvalKind,
+                toolName: toolCall.name,
+                summary,
+                detail: approvalKind === "command" ? String(args.command ?? "") : summary,
+                diff,
+                isDangerous,
+            });
+            if (decision === "no") {
+                const message = "The user denied this operation.";
+                onEvent({
+                    type: "tool-end",
+                    id: toolCall.id,
+                    name: toolCall.name,
+                    summary,
+                    resultPreview: "Denied by user",
+                    isError: true,
+                });
+                return message;
+            }
+            if (decision === "always") {
+                if (approvalKind === "edit")
+                    this.sessionApproveEdits = true;
+                if (approvalKind === "command" && !isDangerous)
+                    this.sessionApproveCommands = true;
+            }
+        }
+        const result = await executeTool(toolCall.name, args, this.toolContext());
+        const previewLines = result.text.split("\n");
+        const resultPreview = previewLines.slice(0, RESULT_PREVIEW_LINES).join("\n") +
+            (previewLines.length > RESULT_PREVIEW_LINES ? `\n… (${previewLines.length} lines)` : "");
+        onEvent({
+            type: "tool-end",
+            id: toolCall.id,
+            name: toolCall.name,
+            summary,
+            resultPreview,
+            isError: Boolean(result.isError),
+            diff: result.isError ? undefined : diff,
+        });
+        return result.text;
+    }
+}

package/dist/core/events.js

@@ -0,0 +1 @@
+export {};

package/dist/core/sessions.js

@@ -0,0 +1,44 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getConfigDir } from "../config/settings.js";
+const MAX_SESSIONS_LISTED = 25;
+function getSessionsDir() {
+    return path.join(getConfigDir(), "sessions");
+}
+export function saveSession(data) {
+    const dir = getSessionsDir();
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, `${data.id}.json`), JSON.stringify(data), { mode: 0o600 });
+}
+export function loadSessionById(id) {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(getSessionsDir(), `${id}.json`), "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Sessions for a workspace, most recently updated first. */
+export function listSessions(cwd) {
+    let files;
+    try {
+        files = fs.readdirSync(getSessionsDir()).filter((f) => f.endsWith(".json"));
+    }
+    catch {
+        return [];
+    }
+    const sessions = [];
+    for (const file of files) {
+        try {
+            const data = JSON.parse(fs.readFileSync(path.join(getSessionsDir(), file), "utf8"));
+            if (data.cwd === cwd && Array.isArray(data.messages) && data.messages.length > 0) {
+                sessions.push(data);
+            }
+        }
+        catch {
+            // skip unreadable session files
+        }
+    }
+    sessions.sort((a, b) => (a.updatedAt < b.updatedAt ? 1 : -1));
+    return sessions.slice(0, MAX_SESSIONS_LISTED);
+}

package/dist/headless.js

@@ -0,0 +1,64 @@
+import { getAuthToken, loadSettings } from "./config/settings.js";
+import { Agent } from "./core/agent.js";
+/** Non-interactive `orbcode -p "prompt"` mode: prints the final response to stdout. */
+export async function runHeadless(prompt, yolo) {
+    const settings = loadSettings();
+    const token = getAuthToken(settings);
+    if (!token) {
+        console.error("Not signed in. Run `orbcode login`, set ORBCODE_TOKEN, or put an apiKey in settings.json.");
+        process.exit(1);
+    }
+    let exitCode = 0;
+    // Only the final content is printed: either the attempt_completion result
+    // or, failing that, the last assistant text. Intermediate text and tool
+    // activity are suppressed.
+    let textBuffer = "";
+    let lastText = "";
+    let completionResult = "";
+    const agent = new Agent({
+        cwd: process.cwd(),
+        token,
+        modelId: settings.model,
+        organizationId: settings.organizationId,
+        baseUrl: settings.baseUrl,
+        autoApproveEdits: yolo,
+        autoApproveSafeCommands: yolo,
+        callbacks: {
+            onEvent: (event) => {
+                switch (event.type) {
+                    case "text-delta":
+                        textBuffer += event.text;
+                        break;
+                    case "text-done":
+                        lastText = textBuffer;
+                        textBuffer = "";
+                        break;
+                    case "completion":
+                        completionResult = event.result;
+                        break;
+                    case "error":
+                        process.stderr.write(`error: ${event.message}\n`);
+                        exitCode = 1;
+                        break;
+                }
+            },
+            // In headless mode there is nobody to ask; deny unless --yolo.
+            requestApproval: async (request) => {
+                if (yolo)
+                    return "yes";
+                process.stderr.write(`[denied] ${request.toolName}: ${request.summary} (pass --yolo to auto-approve)\n`);
+                return "no";
+            },
+            requestFollowup: async (question) => {
+                process.stderr.write(`[followup auto-answered] ${question}\n`);
+                return "Proceed with your best judgment; the user is not available to answer.";
+            },
+        },
+    });
+    await agent.runTurn(prompt);
+    const finalContent = completionResult || lastText || textBuffer;
+    if (finalContent) {
+        process.stdout.write(finalContent.trimEnd() + "\n");
+    }
+    process.exit(exitCode);
+}

package/dist/index.js

@@ -0,0 +1,84 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import { PRODUCT_NAME, VERSION } from "./branding.js";
+import { App } from "./ui/App.js";
+import { runHeadless } from "./headless.js";
+import { loadSessionById } from "./core/sessions.js";
+function printHelp() {
+    console.log(`${PRODUCT_NAME} v${VERSION}
+
+Usage:
+  orbcode                 start an interactive session
+  orbcode "<prompt>"      start an interactive session with an initial prompt
+  orbcode login           sign in to MatterAI
+  orbcode -p "<prompt>"   run a single prompt non-interactively (prints only the final response)
+  orbcode -p "…" --yolo   non-interactive with auto-approved edits/commands
+  orbcode --model <id>    use a specific model for this run
+  orbcode --resume <id>   resume a previous session by id
+  orbcode --version       print version
+  orbcode --help          show this help
+`);
+}
+/** Pop `flag <value>` (accepting -flag and --flag) out of args; returns the value. */
+function takeFlagValue(args, name) {
+    const index = args.findIndex((a) => a === `--${name}` || a === `-${name}`);
+    if (index === -1)
+        return undefined;
+    const value = args[index + 1];
+    if (!value || value.startsWith("-")) {
+        console.error(`Missing value after --${name}`);
+        process.exit(1);
+    }
+    args.splice(index, 2);
+    return value;
+}
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.includes("--version") || args.includes("-v")) {
+        console.log(VERSION);
+        return;
+    }
+    if (args.includes("--help") || args.includes("-h")) {
+        printHelp();
+        return;
+    }
+    const model = takeFlagValue(args, "model") ?? takeFlagValue(args, "m");
+    if (model) {
+        // loadSettings() treats ORBCODE_MODEL as the highest-precedence override,
+        // so the flag reaches both the TUI and headless mode without plumbing.
+        process.env.ORBCODE_MODEL = model;
+    }
+    let initialSession;
+    const resumeId = takeFlagValue(args, "resume") ?? takeFlagValue(args, "r");
+    if (resumeId) {
+        initialSession = loadSessionById(resumeId);
+        if (!initialSession) {
+            console.error(`Session "${resumeId}" not found.`);
+            process.exit(1);
+        }
+    }
+    const printIndex = args.findIndex((a) => a === "-p" || a === "--print");
+    if (printIndex !== -1) {
+        const prompt = args[printIndex + 1];
+        if (!prompt) {
+            console.error("Missing prompt after -p");
+            process.exit(1);
+        }
+        await runHeadless(prompt, args.includes("--yolo"));
+        return;
+    }
+    const initialView = args[0] === "login" ? "login" : undefined;
+    // Any other bare argument starts the TUI with that text as the first prompt.
+    const initialPrompt = initialView ? undefined : args.find((a) => !a.startsWith("-"));
+    // Take over the full terminal: clear the visible screen and home the cursor
+    // so the TUI always starts at the top (prior output stays in scrollback).
+    if (process.stdout.isTTY) {
+        process.stdout.write("\x1b[2J\x1b[H");
+        process.stdout.write("\x1b]0;orbcode\x07");
+    }
+    render(_jsx(App, { initialView: initialView, initialPrompt: initialPrompt, initialSession: initialSession }));
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});