@devang0907/agent-dev 0.1.0

package/README.md

@@ -0,0 +1,58 @@
+# agent-dev
+
+A minimal pi-like terminal coding agent with an Ink UI. Chat with an AI that can read, write, edit files, and run bash commands.
+
+## Quick start
+
+```bash
+npm install
+npm run dev
+```
+
+Set at least one API key:
+
+```bash
+export OPENROUTER_API_KEY=sk-or-...   # Free models (default)
+export OPENAI_API_KEY=sk-...          # ChatGPT
+export GROQ_API_KEY=gsk_...           # Groq
+export GEMINI_API_KEY=...             # Google Gemini
+```
+
+## Providers
+
+| Provider | Env var | Example models |
+|----------|---------|----------------|
+| OpenAI (ChatGPT) | `OPENAI_API_KEY` | `gpt-4o`, `gpt-4o-mini` |
+| Groq | `GROQ_API_KEY` | `llama-3.3-70b-versatile` |
+| Google Gemini | `GEMINI_API_KEY` or `GOOGLE_API_KEY` | `gemini-2.0-flash` |
+| Free (OpenRouter) | `OPENROUTER_API_KEY` | `meta-llama/llama-3.3-70b-instruct:free` |
+
+## Interactive commands
+
+| Command | Description |
+|---------|-------------|
+| `/model` | Open model selector (grouped by provider) |
+| `/model groq` | Open selector filtered by search |
+| `/settings` | Thinking level, theme, API key status |
+| `/new` | Clear session |
+| `/quit` | Exit |
+
+## CLI
+
+```bash
+npm run dev                          # Interactive
+npm run dev -- -p "List files"       # Print mode
+npm run dev -- -c                    # Continue last session
+npm run dev -- --model groq/llama-3.3-70b-versatile "hello"
+npm run build && npm start
+```
+
+Config and sessions are stored in `~/.agent-dev/`.
+
+## Tools
+
+The agent has four built-in tools: `read`, `write`, `edit`, `bash`. File operations are restricted to the current working directory.
+
+## License
+
+MIT

package/dist/agent/loop.d.ts

@@ -0,0 +1,32 @@
+import type { ChatMessage, Model, ToolCall } from "../providers/types.js";
+import type { Settings } from "../config/settings.js";
+export type AgentEvent = {
+    type: "message_start";
+    role: "assistant";
+} | {
+    type: "text_delta";
+    delta: string;
+} | {
+    type: "tool_call";
+    toolCall: ToolCall;
+} | {
+    type: "tool_result";
+    toolCallId: string;
+    name: string;
+    result: string;
+} | {
+    type: "turn_end";
+} | {
+    type: "error";
+    message: string;
+};
+export interface AgentLoopOptions {
+    model: Model;
+    messages: ChatMessage[];
+    settings: Settings;
+    workdir: string;
+    systemPrompt?: string;
+    signal?: AbortSignal;
+    onEvent: (event: AgentEvent) => void;
+}
+export declare function runAgentLoop(options: AgentLoopOptions): Promise<ChatMessage[]>;

package/dist/agent/loop.js

@@ -0,0 +1,83 @@
+import { streamChat } from "../providers/registry.js";
+import { getToolDefinitions, executeTool } from "./tools/index.js";
+const DEFAULT_SYSTEM_PROMPT = `You are a helpful coding assistant with access to tools: read, write, edit, and bash.
+Use tools to inspect and modify the codebase. Be concise and accurate.
+Working directory: ${process.cwd()}`;
+async function collectStream(model, messages, settings, systemPrompt, signal, onEvent) {
+    const tools = getToolDefinitions();
+    let content = "";
+    const toolCallMap = new Map();
+    const stream = streamChat(model, {
+        messages,
+        tools,
+        systemPrompt,
+        thinkingLevel: settings.thinkingLevel,
+        signal,
+    });
+    for await (const event of stream) {
+        if (event.type === "text_delta") {
+            content += event.delta;
+            onEvent?.({ type: "text_delta", delta: event.delta });
+        }
+        else if (event.type === "tool_call_delta") {
+            if (!toolCallMap.has(event.index)) {
+                toolCallMap.set(event.index, { id: event.id ?? "", name: event.name ?? "", arguments: "" });
+            }
+            const tc = toolCallMap.get(event.index);
+            if (event.id)
+                tc.id = event.id;
+            if (event.name)
+                tc.name = event.name;
+            if (event.argumentsDelta)
+                tc.arguments += event.argumentsDelta;
+        }
+        else if (event.type === "error") {
+            return { content, toolCalls: [], error: event.message };
+        }
+    }
+    const toolCalls = Array.from(toolCallMap.values()).filter((tc) => tc.name);
+    return { content, toolCalls };
+}
+export async function runAgentLoop(options) {
+    const { model, messages, settings, workdir, systemPrompt = DEFAULT_SYSTEM_PROMPT, signal, onEvent, } = options;
+    const context = [...messages];
+    while (true) {
+        if (signal?.aborted)
+            break;
+        onEvent({ type: "message_start", role: "assistant" });
+        const { content, toolCalls, error } = await collectStream(model, context, settings, systemPrompt, signal, onEvent);
+        if (error) {
+            onEvent({ type: "error", message: error });
+            break;
+        }
+        const assistantMsg = {
+            role: "assistant",
+            content,
+            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+        };
+        context.push(assistantMsg);
+        if (toolCalls.length === 0) {
+            onEvent({ type: "turn_end" });
+            break;
+        }
+        for (const tc of toolCalls) {
+            onEvent({ type: "tool_call", toolCall: tc });
+            let args = {};
+            try {
+                args = JSON.parse(tc.arguments || "{}");
+            }
+            catch {
+                args = {};
+            }
+            const result = await executeTool(tc.name, args, workdir);
+            onEvent({ type: "tool_result", toolCallId: tc.id, name: tc.name, result });
+            context.push({
+                role: "tool",
+                content: result,
+                toolCallId: tc.id,
+                name: tc.name,
+            });
+        }
+    }
+    return context.slice(messages.length);
+}

package/dist/agent/session.d.ts

@@ -0,0 +1,33 @@
+import { EventEmitter } from "node:events";
+import type { ChatMessage, Model } from "../providers/types.js";
+import type { Settings } from "../config/settings.js";
+import { type AgentEvent } from "./loop.js";
+import { SessionManager } from "../session/manager.js";
+export type SessionEvent = AgentEvent | {
+    type: "user_message";
+    content: string;
+} | {
+    type: "model_changed";
+    model: Model;
+};
+export declare class AgentSession extends EventEmitter {
+    private messages;
+    private model;
+    private settings;
+    private workdir;
+    private sessionManager;
+    private abortController?;
+    private running;
+    constructor(settings: Settings, sessionManager: SessionManager, workdir: string, initialModel?: Model);
+    getModel(): Model;
+    getSettings(): Settings;
+    getMessages(): ChatMessage[];
+    isRunning(): boolean;
+    setModel(model: Model): void;
+    updateSettings(settings: Settings): void;
+    abort(): void;
+    prompt(content: string): Promise<void>;
+    newSession(): void;
+    getAvailableModels(): Model[];
+    static resolveInitialModel(settings: Settings, modelRef?: string): Model | undefined;
+}

package/dist/agent/session.js

@@ -0,0 +1,107 @@
+import { EventEmitter } from "node:events";
+import { findModel } from "../config/models.js";
+import { setDefaultModel, saveSettings } from "../config/settings.js";
+import { getAvailableModels, getDefaultModelForProvider } from "../providers/registry.js";
+import { runAgentLoop } from "./loop.js";
+export class AgentSession extends EventEmitter {
+    messages = [];
+    model;
+    settings;
+    workdir;
+    sessionManager;
+    abortController;
+    running = false;
+    constructor(settings, sessionManager, workdir, initialModel) {
+        super();
+        this.settings = settings;
+        this.sessionManager = sessionManager;
+        this.workdir = workdir;
+        this.messages = sessionManager.getMessages();
+        const available = getAvailableModels(settings);
+        const fromSettings = findModel(settings.defaultProvider, settings.defaultModel);
+        this.model =
+            initialModel ??
+                (fromSettings && available.some((m) => m.provider === fromSettings.provider && m.id === fromSettings.id)
+                    ? fromSettings
+                    : available[0] ?? findModel("free", "meta-llama/llama-3.3-70b-instruct:free"));
+    }
+    getModel() {
+        return this.model;
+    }
+    getSettings() {
+        return this.settings;
+    }
+    getMessages() {
+        return [...this.messages];
+    }
+    isRunning() {
+        return this.running;
+    }
+    setModel(model) {
+        this.model = model;
+        this.settings = setDefaultModel(this.settings, model.provider, model.id);
+        this.sessionManager.appendModelChange(model);
+        this.emit("event", { type: "model_changed", model });
+    }
+    updateSettings(settings) {
+        this.settings = settings;
+        saveSettings(settings);
+    }
+    abort() {
+        this.abortController?.abort();
+    }
+    async prompt(content) {
+        if (this.running)
+            return;
+        this.running = true;
+        const userMsg = { role: "user", content };
+        this.messages.push(userMsg);
+        this.sessionManager.appendMessage(userMsg);
+        this.emit("event", { type: "user_message", content });
+        this.abortController = new AbortController();
+        try {
+            const newMessages = await runAgentLoop({
+                model: this.model,
+                messages: [...this.messages],
+                settings: this.settings,
+                workdir: this.workdir,
+                signal: this.abortController.signal,
+                onEvent: (event) => this.emit("event", event),
+            });
+            for (const msg of newMessages) {
+                if (msg.role !== "user") {
+                    this.messages.push(msg);
+                    this.sessionManager.appendMessage(msg);
+                }
+            }
+        }
+        finally {
+            this.running = false;
+            this.abortController = undefined;
+            this.sessionManager.saveAsLast();
+        }
+    }
+    newSession() {
+        this.messages = [];
+        this.sessionManager.clear();
+    }
+    getAvailableModels() {
+        return getAvailableModels(this.settings);
+    }
+    static resolveInitialModel(settings, modelRef) {
+        if (modelRef) {
+            const slash = modelRef.indexOf("/");
+            if (slash > 0) {
+                const provider = modelRef.slice(0, slash);
+                const id = modelRef.slice(slash + 1);
+                return findModel(provider, id);
+            }
+        }
+        const available = getAvailableModels(settings);
+        const fromSettings = findModel(settings.defaultProvider, settings.defaultModel);
+        if (fromSettings && available.some((m) => m.provider === fromSettings.provider && m.id === fromSettings.id)) {
+            return fromSettings;
+        }
+        return available[0] ?? getDefaultModelForProvider(settings.defaultProvider);
+    }
+}

package/dist/agent/tools/index.d.ts

@@ -0,0 +1,8 @@
+import type { ToolDefinition } from "../../providers/types.js";
+export interface AgentTool {
+    definition: ToolDefinition;
+    execute: (args: Record<string, unknown>, workdir: string) => Promise<string>;
+}
+export declare const BUILTIN_TOOLS: AgentTool[];
+export declare function getToolDefinitions(): ToolDefinition[];
+export declare function executeTool(name: string, args: Record<string, unknown>, workdir: string): Promise<string>;

package/dist/agent/tools/index.js

@@ -0,0 +1,21 @@
+import { readTool, writeTool, editTool, bashTool, executeRead, executeWrite, executeEdit, executeBash, } from "./read.js";
+export const BUILTIN_TOOLS = [
+    { definition: readTool, execute: (args, wd) => executeRead(args, wd) },
+    { definition: writeTool, execute: (args, wd) => executeWrite(args, wd) },
+    { definition: editTool, execute: (args, wd) => executeEdit(args, wd) },
+    { definition: bashTool, execute: (args, wd) => executeBash(args, wd) },
+];
+export function getToolDefinitions() {
+    return BUILTIN_TOOLS.map((t) => t.definition);
+}
+export async function executeTool(name, args, workdir) {
+    const tool = BUILTIN_TOOLS.find((t) => t.definition.name === name);
+    if (!tool)
+        return `Error: unknown tool ${name}`;
+    try {
+        return await tool.execute(args, workdir);
+    }
+    catch (err) {
+        return `Error: ${err instanceof Error ? err.message : String(err)}`;
+    }
+}

package/dist/agent/tools/read.d.ts

@@ -0,0 +1,20 @@
+import type { ToolDefinition } from "../../providers/types.js";
+export declare const readTool: ToolDefinition;
+export declare function executeRead(args: {
+    path: string;
+}, workdir?: string): Promise<string>;
+export declare const writeTool: ToolDefinition;
+export declare function executeWrite(args: {
+    path: string;
+    content: string;
+}, workdir?: string): Promise<string>;
+export declare const editTool: ToolDefinition;
+export declare function executeEdit(args: {
+    path: string;
+    old_string: string;
+    new_string: string;
+}, workdir?: string): Promise<string>;
+export declare const bashTool: ToolDefinition;
+export declare function executeBash(args: {
+    command: string;
+}, workdir?: string): Promise<string>;

package/dist/agent/tools/read.js

@@ -0,0 +1,108 @@
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { resolve, isAbsolute } from "node:path";
+const DEFAULT_WORKDIR = process.cwd();
+function resolvePath(path, workdir = DEFAULT_WORKDIR) {
+    return isAbsolute(path) ? path : resolve(workdir, path);
+}
+function assertWithinWorkdir(path, workdir = DEFAULT_WORKDIR) {
+    const resolved = resolve(path);
+    const root = resolve(workdir);
+    if (!resolved.startsWith(root)) {
+        throw new Error(`Path outside working directory: ${path}`);
+    }
+}
+export const readTool = {
+    name: "read",
+    description: "Read the contents of a file",
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "File path relative to project root" },
+        },
+        required: ["path"],
+    },
+};
+export async function executeRead(args, workdir = DEFAULT_WORKDIR) {
+    const filePath = resolvePath(args.path, workdir);
+    assertWithinWorkdir(filePath, workdir);
+    if (!existsSync(filePath)) {
+        return `Error: file not found: ${args.path}`;
+    }
+    const content = readFileSync(filePath, "utf-8");
+    return content.length > 50000 ? content.slice(0, 50000) + "\n... (truncated)" : content;
+}
+export const writeTool = {
+    name: "write",
+    description: "Write content to a file (creates or overwrites)",
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "File path relative to project root" },
+            content: { type: "string", description: "Content to write" },
+        },
+        required: ["path", "content"],
+    },
+};
+export async function executeWrite(args, workdir = DEFAULT_WORKDIR) {
+    const filePath = resolvePath(args.path, workdir);
+    assertWithinWorkdir(filePath, workdir);
+    writeFileSync(filePath, args.content, "utf-8");
+    return `Written ${args.content.length} bytes to ${args.path}`;
+}
+export const editTool = {
+    name: "edit",
+    description: "Replace old_string with new_string in a file",
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "File path relative to project root" },
+            old_string: { type: "string", description: "String to find" },
+            new_string: { type: "string", description: "Replacement string" },
+        },
+        required: ["path", "old_string", "new_string"],
+    },
+};
+export async function executeEdit(args, workdir = DEFAULT_WORKDIR) {
+    const filePath = resolvePath(args.path, workdir);
+    assertWithinWorkdir(filePath, workdir);
+    if (!existsSync(filePath)) {
+        return `Error: file not found: ${args.path}`;
+    }
+    const content = readFileSync(filePath, "utf-8");
+    if (!content.includes(args.old_string)) {
+        return `Error: old_string not found in ${args.path}`;
+    }
+    const newContent = content.replace(args.old_string, args.new_string);
+    writeFileSync(filePath, newContent, "utf-8");
+    return `Edited ${args.path}`;
+}
+export const bashTool = {
+    name: "bash",
+    description: "Run a shell command in the project directory",
+    parameters: {
+        type: "object",
+        properties: {
+            command: { type: "string", description: "Shell command to execute" },
+        },
+        required: ["command"],
+    },
+};
+export async function executeBash(args, workdir = DEFAULT_WORKDIR) {
+    const { exec } = await import("node:child_process");
+    const { promisify } = await import("node:util");
+    const execAsync = promisify(exec);
+    try {
+        const { stdout, stderr } = await execAsync(args.command, {
+            cwd: workdir,
+            timeout: 120000,
+            maxBuffer: 1024 * 1024,
+        });
+        const out = stdout + (stderr ? `\n${stderr}` : "");
+        return out.trim() || "(no output)";
+    }
+    catch (err) {
+        const e = err;
+        const out = (e.stdout ?? "") + (e.stderr ? `\n${e.stderr}` : "");
+        return out.trim() || (e.message ?? "Command failed");
+    }
+}

package/dist/cli/args.d.ts

@@ -0,0 +1,9 @@
+export interface CliArgs {
+    print: boolean;
+    continueSession: boolean;
+    model?: string;
+    prompt?: string;
+    help: boolean;
+}
+export declare function parseArgs(argv: string[]): CliArgs;
+export declare function printHelp(): void;

package/dist/cli/args.js

@@ -0,0 +1,60 @@
+export function parseArgs(argv) {
+    const args = argv.slice(2);
+    const result = {
+        print: false,
+        continueSession: false,
+        help: false,
+    };
+    const positional = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "-h" || arg === "--help") {
+            result.help = true;
+        }
+        else if (arg === "-p" || arg === "--print") {
+            result.print = true;
+        }
+        else if (arg === "-c" || arg === "--continue") {
+            result.continueSession = true;
+        }
+        else if (arg === "--model" && args[i + 1]) {
+            result.model = args[++i];
+        }
+        else if (!arg.startsWith("-")) {
+            positional.push(arg);
+        }
+    }
+    if (positional.length > 0) {
+        result.prompt = positional.join(" ");
+    }
+    return result;
+}
+export function printHelp() {
+    console.log(`
+agent-dev — minimal pi-like coding agent
+
+Usage:
+  agent                          Interactive mode
+  agent -p "prompt"              Print mode (no TUI)
+  agent -c                       Continue last session
+  agent --model groq/llama-3.3-70b-versatile "prompt"
+
+Options:
+  -p, --print          Print response and exit
+  -c, --continue       Continue most recent session
+  --model <ref>        Provider/model (e.g. openai/gpt-4o)
+  -h, --help           Show help
+
+Commands (interactive):
+  /model [search]      Select model
+  /settings            Settings menu
+  /new                 New session
+  /quit                Quit
+
+Environment:
+  OPENAI_API_KEY       OpenAI (ChatGPT)
+  GROQ_API_KEY         Groq
+  GEMINI_API_KEY       Google Gemini
+  OPENROUTER_API_KEY   Free models via OpenRouter
+`);
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { main } from "./main.js";
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/config/models.d.ts

@@ -0,0 +1,6 @@
+import type { Model, ProviderId } from "../providers/types.js";
+export declare const PROVIDER_LABELS: Record<ProviderId, string>;
+export declare const ALL_MODELS: Model[];
+export declare function findModel(provider: ProviderId, id: string): Model | undefined;
+export declare function parseModelRef(ref: string): Model | undefined;
+export declare function modelRef(model: Model): string;

package/dist/config/models.js

@@ -0,0 +1,43 @@
+export const PROVIDER_LABELS = {
+    openai: "OpenAI (ChatGPT)",
+    groq: "Groq",
+    gemini: "Google Gemini",
+    free: "Free (OpenRouter)",
+};
+export const ALL_MODELS = [
+    { provider: "openai", id: "gpt-4o", name: "GPT-4o" },
+    { provider: "openai", id: "gpt-4o-mini", name: "GPT-4o Mini" },
+    { provider: "groq", id: "llama-3.3-70b-versatile", name: "Llama 3.3 70B" },
+    { provider: "groq", id: "openai/gpt-oss-120b", name: "GPT-OSS 120B" },
+    { provider: "gemini", id: "gemini-2.0-flash", name: "Gemini 2.0 Flash" },
+    { provider: "gemini", id: "gemini-2.5-flash", name: "Gemini 2.5 Flash" },
+    {
+        provider: "free",
+        id: "meta-llama/llama-3.3-70b-instruct:free",
+        name: "Llama 3.3 70B (free)",
+    },
+    {
+        provider: "free",
+        id: "google/gemini-2.0-flash-exp:free",
+        name: "Gemini 2.0 Flash (free)",
+    },
+    {
+        provider: "free",
+        id: "qwen/qwen-2.5-72b-instruct:free",
+        name: "Qwen 2.5 72B (free)",
+    },
+];
+export function findModel(provider, id) {
+    return ALL_MODELS.find((m) => m.provider === provider && m.id === id);
+}
+export function parseModelRef(ref) {
+    const slash = ref.indexOf("/");
+    if (slash === -1)
+        return undefined;
+    const provider = ref.slice(0, slash);
+    const id = ref.slice(slash + 1);
+    return findModel(provider, id);
+}
+export function modelRef(model) {
+    return `${model.provider}/${model.id}`;
+}

package/dist/config/paths.d.ts

@@ -0,0 +1,4 @@
+export declare const CONFIG_DIR: string;
+export declare const SETTINGS_PATH: string;
+export declare const SESSIONS_DIR: string;
+export declare const LAST_SESSION_PATH: string;

package/dist/config/paths.js

@@ -0,0 +1,6 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+export const CONFIG_DIR = process.env.AGENT_DEV_DIR ?? join(homedir(), ".agent-dev");
+export const SETTINGS_PATH = join(CONFIG_DIR, "settings.json");
+export const SESSIONS_DIR = join(CONFIG_DIR, "sessions");
+export const LAST_SESSION_PATH = join(CONFIG_DIR, "last-session.json");

package/dist/config/settings.d.ts

@@ -0,0 +1,12 @@
+import type { ProviderId } from "../providers/types.js";
+import type { ThinkingLevel, Theme } from "../providers/types.js";
+export interface Settings {
+    defaultProvider: ProviderId;
+    defaultModel: string;
+    thinkingLevel: ThinkingLevel;
+    theme: Theme;
+    apiKeys?: Partial<Record<ProviderId, string>>;
+}
+export declare function loadSettings(): Settings;
+export declare function saveSettings(settings: Settings): void;
+export declare function setDefaultModel(settings: Settings, provider: ProviderId, modelId: string): Settings;

package/dist/config/settings.js

@@ -0,0 +1,29 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { CONFIG_DIR, SETTINGS_PATH } from "./paths.js";
+const DEFAULT_SETTINGS = {
+    defaultProvider: "free",
+    defaultModel: "meta-llama/llama-3.3-70b-instruct:free",
+    thinkingLevel: "off",
+    theme: "dark",
+};
+export function loadSettings() {
+    if (!existsSync(SETTINGS_PATH)) {
+        return { ...DEFAULT_SETTINGS };
+    }
+    try {
+        const raw = readFileSync(SETTINGS_PATH, "utf-8");
+        return { ...DEFAULT_SETTINGS, ...JSON.parse(raw) };
+    }
+    catch {
+        return { ...DEFAULT_SETTINGS };
+    }
+}
+export function saveSettings(settings) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf-8");
+}
+export function setDefaultModel(settings, provider, modelId) {
+    const updated = { ...settings, defaultProvider: provider, defaultModel: modelId };
+    saveSettings(updated);
+    return updated;
+}

package/dist/main.d.ts

@@ -0,0 +1 @@
+export declare function main(): Promise<void>;