codemaxxing 0.1.0

package/README.md

@@ -0,0 +1,209 @@
+# codemaxxing 💪
+
+> your code. your model. no excuses.
+
+Open-source terminal coding agent. Connect **any** LLM — local or remote — and start building. Like Claude Code, but you bring your own model.
+
+## Why?
+
+Every coding agent locks you into their API. Codemaxxing doesn't. Run it with LM Studio, Ollama, OpenRouter, OpenAI, or any OpenAI-compatible endpoint. Your machine, your model, your rules.
+
+## Quick Install (Recommended)
+
+**Linux / macOS:**
+```bash
+bash -c "$(curl -fsSL https://raw.githubusercontent.com/MarcosV6/codemaxxing/main/install.sh)"
+```
+
+**Windows (PowerShell as Administrator):**
+```powershell
+curl -fsSL -o $env:TEMP\install-codemaxxing.bat https://raw.githubusercontent.com/MarcosV6/codemaxxing/main/install.bat; & $env:TEMP\install-codemaxxing.bat
+```
+
+**Windows (CMD as Administrator):**
+```
+curl -fsSL -o %TEMP%\install-codemaxxing.bat https://raw.githubusercontent.com/MarcosV6/codemaxxing/main/install.bat && %TEMP%\install-codemaxxing.bat
+```
+
+> **Note:** Restart your terminal after installation to ensure everything works.
+
+## Manual Installation
+
+**Prerequisites:** [Node.js](https://nodejs.org) 20 or later.
+
+**NPM:**
+```bash
+npm install -g codemaxxing
+```
+
+## Quick Start
+
+### 1. Start Your LLM
+
+You need a local LLM server running. The easiest option:
+
+1. Download [LM Studio](https://lmstudio.ai)
+2. Search for a model (e.g. **Qwen 2.5 Coder 7B Q4_K_M** — good for testing)
+3. Load the model
+4. Click **Start Server** (it runs on port 1234 by default)
+
+### 2. Run It
+
+```bash
+codemaxxing
+```
+
+That's it. Codemaxxing auto-detects LM Studio and connects. Start coding.
+
+---
+
+## Advanced Setup
+
+**With a remote provider (OpenAI, OpenRouter, etc.):**
+
+```bash
+codemaxxing --base-url https://api.openai.com/v1 --api-key sk-... --model gpt-4o
+```
+
+**With a saved provider profile:**
+
+```bash
+codemaxxing --provider openrouter
+```
+
+**Auto-detected local servers:** LM Studio (`:1234`), Ollama (`:11434`), vLLM (`:8000`)
+
+## Features
+
+### 🔥 Streaming Tokens
+Real-time token display. See the model think, not just the final answer.
+
+### ⚠️ Tool Approval
+Dangerous operations (file writes, shell commands) require your approval. Press `y` to allow, `n` to deny, `a` to always allow for the session.
+
+### 📂 Smart Context (Repo Map)
+Automatically scans your codebase and builds a map of functions, classes, and types. The model knows what exists where without reading every file.
+
+### 🔀 Git Integration
+Opt-in git commands built in:
+- `/commit <message>` — stage all + commit
+- `/push` — push to remote
+- `/diff` — show changes
+- `/undo` — revert last codemaxxing commit
+- `/git on` / `/git off` — toggle auto-commits
+
+### 💾 Session Persistence
+Conversations auto-save to SQLite. Pick up where you left off:
+- `/sessions` — list past sessions
+- `/resume` — interactive session picker
+
+### 🔄 Multi-Provider
+Switch models mid-session without restarting:
+- `/model gpt-4o` — switch to a different model
+- `/models` — list available models from your provider
+
+### 📋 Smart Paste
+Paste large code blocks without breaking the UI. Multi-line pastes collapse into `[Pasted text #1 +N lines]` badges (like Claude Code).
+
+### ⌨️ Slash Commands
+Type `/` for autocomplete suggestions. Arrow keys to navigate, Tab or Enter to select.
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/help` | Show all commands |
+| `/model <name>` | Switch model mid-session |
+| `/models` | List available models |
+| `/map` | Show repository map |
+| `/sessions` | List past sessions |
+| `/resume` | Resume a past session |
+| `/reset` | Clear conversation |
+| `/context` | Show message count + tokens |
+| `/diff` | Show git changes |
+| `/commit <msg>` | Stage all + commit |
+| `/push` | Push to remote |
+| `/undo` | Revert last codemaxxing commit |
+| `/git on/off` | Toggle auto-commits |
+| `/quit` | Exit |
+
+## CLI Flags
+
+```
+-m, --model <model>       Model name to use
+-p, --provider <name>     Provider profile from config
+-k, --api-key <key>       API key for the provider
+-u, --base-url <url>      Base URL for the provider API
+-h, --help                Show help
+```
+
+## Config
+
+Settings are stored in `~/.codemaxxing/settings.json`:
+
+```json
+{
+  "provider": {
+    "baseUrl": "http://localhost:1234/v1",
+    "apiKey": "not-needed",
+    "model": "auto"
+  },
+  "providers": {
+    "local": {
+      "name": "Local (LM Studio/Ollama)",
+      "baseUrl": "http://localhost:1234/v1",
+      "apiKey": "not-needed",
+      "model": "auto"
+    },
+    "openrouter": {
+      "name": "OpenRouter",
+      "baseUrl": "https://openrouter.ai/api/v1",
+      "apiKey": "sk-or-...",
+      "model": "anthropic/claude-sonnet-4"
+    },
+    "openai": {
+      "name": "OpenAI",
+      "baseUrl": "https://api.openai.com/v1",
+      "apiKey": "sk-...",
+      "model": "gpt-4o"
+    }
+  },
+  "defaults": {
+    "autoApprove": false,
+    "maxTokens": 8192
+  }
+}
+```
+
+## Tools
+
+Codemaxxing gives the model these tools:
+
+- **read_file** — Read file contents (safe)
+- **write_file** — Write/create files (requires approval)
+- **list_files** — List directory contents (safe)
+- **search_files** — Search for patterns across files (safe)
+- **run_command** — Execute shell commands (requires approval)
+
+## Project Context
+
+Drop a `CODEMAXXING.md` file in your project root to give the model extra context about your codebase, conventions, or instructions. It's automatically included in the system prompt.
+
+## Stack
+
+- **Runtime:** Node.js + TypeScript
+- **TUI:** [Ink](https://github.com/vadimdemedes/ink) (React for the terminal)
+- **LLM SDK:** [OpenAI SDK](https://github.com/openai/openai-node) (works with any compatible API)
+- **Sessions:** [better-sqlite3](https://github.com/WiseLibs/better-sqlite3)
+- **Zero cloud dependencies** — everything runs locally
+
+## Inspired By
+
+Built by studying the best:
+- [Aider](https://github.com/paul-gauthier/aider) — repo map concept, auto-commit
+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code) — permission system, paste handling
+- [OpenCode](https://github.com/opencode-ai/opencode) — multi-provider, SQLite sessions
+
+## License
+
+MIT

package/dist/agent.d.ts

@@ -0,0 +1,65 @@
+import type { ProviderConfig } from "./config.js";
+export interface AgentOptions {
+    provider: ProviderConfig;
+    cwd: string;
+    maxTokens: number;
+    autoApprove: boolean;
+    onToken?: (token: string) => void;
+    onToolCall?: (name: string, args: Record<string, unknown>) => void;
+    onToolResult?: (name: string, result: string) => void;
+    onThinking?: (text: string) => void;
+    onToolApproval?: (name: string, args: Record<string, unknown>) => Promise<"yes" | "no" | "always">;
+    onGitCommit?: (message: string) => void;
+}
+export declare class CodingAgent {
+    private options;
+    private client;
+    private messages;
+    private tools;
+    private cwd;
+    private maxTokens;
+    private autoApprove;
+    private model;
+    private alwaysApproved;
+    private gitEnabled;
+    private autoCommitEnabled;
+    private repoMap;
+    private sessionId;
+    constructor(options: AgentOptions);
+    /**
+     * Initialize the agent — call this after constructor to build async context
+     */
+    init(): Promise<void>;
+    /**
+     * Resume an existing session by loading its messages
+     */
+    resume(sessionId: string): Promise<void>;
+    getSessionId(): string;
+    /**
+     * Get the current repo map
+     */
+    getRepoMap(): string;
+    /**
+     * Rebuild the repo map (useful after file changes)
+     */
+    refreshRepoMap(): Promise<string>;
+    /**
+     * Stream a response from the model.
+     * Assembles tool call chunks, emits tokens in real-time,
+     * and loops until the model responds with text (no more tool calls).
+     */
+    chat(userMessage: string): Promise<string>;
+    /**
+     * Switch to a different model mid-session
+     */
+    switchModel(model: string, baseUrl?: string, apiKey?: string): void;
+    getModel(): string;
+    setAutoCommit(enabled: boolean): void;
+    isGitEnabled(): boolean;
+    getContextLength(): number;
+    /**
+     * Estimate token count across all messages (~4 chars per token)
+     */
+    estimateTokens(): number;
+    reset(): void;
+}

package/dist/agent.js

@@ -0,0 +1,269 @@
+import OpenAI from "openai";
+import { FILE_TOOLS, executeTool } from "./tools/files.js";
+import { buildProjectContext, getSystemPrompt } from "./utils/context.js";
+import { isGitRepo, autoCommit } from "./utils/git.js";
+import { createSession, saveMessage, updateTokenEstimate, loadMessages } from "./utils/sessions.js";
+// Tools that can modify your project — require approval
+const DANGEROUS_TOOLS = new Set(["write_file", "run_command"]);
+export class CodingAgent {
+    options;
+    client;
+    messages = [];
+    tools = FILE_TOOLS;
+    cwd;
+    maxTokens;
+    autoApprove;
+    model;
+    alwaysApproved = new Set();
+    gitEnabled;
+    autoCommitEnabled = false;
+    repoMap = "";
+    sessionId = "";
+    constructor(options) {
+        this.options = options;
+        this.client = new OpenAI({
+            baseURL: options.provider.baseUrl,
+            apiKey: options.provider.apiKey,
+        });
+        this.cwd = options.cwd;
+        this.maxTokens = options.maxTokens;
+        this.autoApprove = options.autoApprove;
+        this.model = options.provider.model;
+        this.gitEnabled = isGitRepo(this.cwd);
+    }
+    /**
+     * Initialize the agent — call this after constructor to build async context
+     */
+    async init() {
+        const context = await buildProjectContext(this.cwd);
+        const systemPrompt = await getSystemPrompt(context);
+        this.messages = [
+            { role: "system", content: systemPrompt },
+        ];
+        // Create a new session
+        this.sessionId = createSession(this.cwd, this.model);
+        saveMessage(this.sessionId, this.messages[0]);
+    }
+    /**
+     * Resume an existing session by loading its messages
+     */
+    async resume(sessionId) {
+        const messages = loadMessages(sessionId);
+        if (messages.length === 0) {
+            throw new Error(`Session ${sessionId} not found or empty`);
+        }
+        this.messages = messages;
+        this.sessionId = sessionId;
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    /**
+     * Get the current repo map
+     */
+    getRepoMap() {
+        return this.repoMap;
+    }
+    /**
+     * Rebuild the repo map (useful after file changes)
+     */
+    async refreshRepoMap() {
+        const { buildRepoMap } = await import("./utils/repomap.js");
+        this.repoMap = await buildRepoMap(this.cwd);
+        return this.repoMap;
+    }
+    /**
+     * Stream a response from the model.
+     * Assembles tool call chunks, emits tokens in real-time,
+     * and loops until the model responds with text (no more tool calls).
+     */
+    async chat(userMessage) {
+        const userMsg = { role: "user", content: userMessage };
+        this.messages.push(userMsg);
+        saveMessage(this.sessionId, userMsg);
+        let iterations = 0;
+        const MAX_ITERATIONS = 20;
+        while (iterations < MAX_ITERATIONS) {
+            iterations++;
+            const stream = await this.client.chat.completions.create({
+                model: this.model,
+                messages: this.messages,
+                tools: this.tools,
+                max_tokens: this.maxTokens,
+                stream: true,
+            });
+            // Accumulate the streamed response
+            let contentText = "";
+            let thinkingText = "";
+            let inThinking = false;
+            const toolCalls = new Map();
+            for await (const chunk of stream) {
+                const delta = chunk.choices?.[0]?.delta;
+                if (!delta)
+                    continue;
+                // Handle content tokens (the actual response text)
+                if (delta.content) {
+                    const token = delta.content;
+                    // Detect <think> blocks from reasoning models (Qwen, DeepSeek, etc.)
+                    if (token.includes("<think>")) {
+                        inThinking = true;
+                        thinkingText = "";
+                        continue;
+                    }
+                    if (inThinking) {
+                        if (token.includes("</think>")) {
+                            inThinking = false;
+                            this.options.onThinking?.(thinkingText.trim());
+                            continue;
+                        }
+                        thinkingText += token;
+                        continue;
+                    }
+                    contentText += token;
+                    this.options.onToken?.(token);
+                }
+                // Handle tool call chunks — they arrive in pieces
+                if (delta.tool_calls) {
+                    for (const tc of delta.tool_calls) {
+                        const idx = tc.index;
+                        if (!toolCalls.has(idx)) {
+                            toolCalls.set(idx, {
+                                id: tc.id ?? "",
+                                name: tc.function?.name ?? "",
+                                arguments: "",
+                            });
+                        }
+                        const existing = toolCalls.get(idx);
+                        if (tc.id)
+                            existing.id = tc.id;
+                        if (tc.function?.name)
+                            existing.name = tc.function.name;
+                        if (tc.function?.arguments)
+                            existing.arguments += tc.function.arguments;
+                    }
+                }
+            }
+            // Build the assistant message for history
+            const assistantMessage = { role: "assistant", content: contentText || null };
+            if (toolCalls.size > 0) {
+                assistantMessage.tool_calls = Array.from(toolCalls.values()).map((tc) => ({
+                    id: tc.id,
+                    type: "function",
+                    function: { name: tc.name, arguments: tc.arguments },
+                }));
+            }
+            this.messages.push(assistantMessage);
+            saveMessage(this.sessionId, assistantMessage);
+            // If no tool calls, we're done — return the text
+            if (toolCalls.size === 0) {
+                updateTokenEstimate(this.sessionId, this.estimateTokens());
+                return contentText || "(empty response)";
+            }
+            // Process tool calls
+            for (const toolCall of toolCalls.values()) {
+                let args = {};
+                try {
+                    args = JSON.parse(toolCall.arguments);
+                }
+                catch {
+                    args = {};
+                }
+                this.options.onToolCall?.(toolCall.name, args);
+                // Check approval for dangerous tools
+                if (DANGEROUS_TOOLS.has(toolCall.name) && !this.autoApprove && !this.alwaysApproved.has(toolCall.name)) {
+                    if (this.options.onToolApproval) {
+                        const decision = await this.options.onToolApproval(toolCall.name, args);
+                        if (decision === "no") {
+                            const denied = `Tool call "${toolCall.name}" was denied by the user.`;
+                            this.options.onToolResult?.(toolCall.name, denied);
+                            const deniedMsg = {
+                                role: "tool",
+                                tool_call_id: toolCall.id,
+                                content: denied,
+                            };
+                            this.messages.push(deniedMsg);
+                            saveMessage(this.sessionId, deniedMsg);
+                            continue;
+                        }
+                        if (decision === "always") {
+                            this.alwaysApproved.add(toolCall.name);
+                        }
+                    }
+                }
+                const result = await executeTool(toolCall.name, args, this.cwd);
+                this.options.onToolResult?.(toolCall.name, result);
+                // Auto-commit after successful write_file (only if enabled)
+                if (this.gitEnabled && this.autoCommitEnabled && toolCall.name === "write_file" && result.startsWith("✅")) {
+                    const path = String(args.path ?? "unknown");
+                    const committed = autoCommit(this.cwd, path, "write");
+                    if (committed) {
+                        this.options.onGitCommit?.(`write ${path}`);
+                    }
+                }
+                const toolMsg = {
+                    role: "tool",
+                    tool_call_id: toolCall.id,
+                    content: result,
+                };
+                this.messages.push(toolMsg);
+                saveMessage(this.sessionId, toolMsg);
+            }
+            // Reset content for next iteration (tool results → model responds again)
+            // The onToken callback will stream the next response too
+        }
+        return "Max iterations reached. The agent may be stuck in a loop.";
+    }
+    /**
+     * Switch to a different model mid-session
+     */
+    switchModel(model, baseUrl, apiKey) {
+        this.model = model;
+        if (baseUrl || apiKey) {
+            this.client = new OpenAI({
+                baseURL: baseUrl ?? this.options.provider.baseUrl,
+                apiKey: apiKey ?? this.options.provider.apiKey,
+            });
+        }
+    }
+    getModel() {
+        return this.model;
+    }
+    setAutoCommit(enabled) {
+        this.autoCommitEnabled = enabled;
+    }
+    isGitEnabled() {
+        return this.gitEnabled;
+    }
+    getContextLength() {
+        return this.messages.length;
+    }
+    /**
+     * Estimate token count across all messages (~4 chars per token)
+     */
+    estimateTokens() {
+        let chars = 0;
+        for (const msg of this.messages) {
+            if (typeof msg.content === "string") {
+                chars += msg.content.length;
+            }
+            else if (Array.isArray(msg.content)) {
+                for (const part of msg.content) {
+                    if ("text" in part)
+                        chars += part.text.length;
+                }
+            }
+            // Count tool call arguments too
+            if ("tool_calls" in msg && Array.isArray(msg.tool_calls)) {
+                for (const tc of msg.tool_calls) {
+                    chars += (tc.function?.arguments?.length ?? 0);
+                    chars += (tc.function?.name?.length ?? 0);
+                }
+            }
+        }
+        return Math.ceil(chars / 4);
+    }
+    reset() {
+        const systemMsg = this.messages[0];
+        this.messages = [systemMsg];
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,41 @@
+export interface ProviderConfig {
+    baseUrl: string;
+    apiKey: string;
+    model: string;
+}
+export interface ProviderProfile extends ProviderConfig {
+    name: string;
+}
+export interface CodemaxxingConfig {
+    provider: ProviderConfig;
+    providers?: Record<string, ProviderProfile>;
+    defaults: {
+        autoApprove: boolean;
+        contextFiles: number;
+        maxTokens: number;
+    };
+}
+export interface CLIArgs {
+    model?: string;
+    provider?: string;
+    apiKey?: string;
+    baseUrl?: string;
+}
+/**
+ * Parse CLI arguments
+ */
+export declare function parseCLIArgs(): CLIArgs;
+export declare function loadConfig(): CodemaxxingConfig;
+/**
+ * Apply CLI overrides to a provider config
+ */
+export declare function applyOverrides(config: CodemaxxingConfig, args: CLIArgs): CodemaxxingConfig;
+export declare function getConfigPath(): string;
+/**
+ * Auto-detect local LLM servers
+ */
+export declare function detectLocalProvider(): Promise<ProviderConfig | null>;
+/**
+ * List available models from a provider endpoint
+ */
+export declare function listModels(baseUrl: string, apiKey: string): Promise<string[]>;