codemaxxing 0.2.1 → 0.3.0

package/dist/index.js

@@ -54,6 +54,10 @@ const SLASH_COMMANDS = [
     { cmd: "/skills search", desc: "search registry" },
     { cmd: "/skills on", desc: "enable skill for session" },
     { cmd: "/skills off", desc: "disable skill for session" },
+    { cmd: "/architect", desc: "toggle architect mode" },
+    { cmd: "/lint", desc: "show auto-lint status" },
+    { cmd: "/lint on", desc: "enable auto-lint" },
+    { cmd: "/lint off", desc: "disable auto-lint" },
     { cmd: "/quit", desc: "exit" },
 ];
 const SPINNER_FRAMES = ["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"];
@@ -236,6 +240,12 @@ function App() {
                 const savedStr = saved >= 1000 ? `${(saved / 1000).toFixed(1)}k` : String(saved);
                 addMsg("info", `📦 Context compressed (~${savedStr} tokens freed)`);
             },
+            onArchitectPlan: (plan) => {
+                addMsg("info", `🏗️ Architect Plan:\n${plan}`);
+            },
+            onLintResult: (file, errors) => {
+                addMsg("info", `🔍 Lint errors in ${file}:\n${errors}`);
+            },
             contextCompressionThreshold: config.defaults.contextCompressionThreshold,
             onToolApproval: (name, args, diff) => {
                 return new Promise((resolve) => {
@@ -246,6 +256,12 @@ function App() {
         });
         // Initialize async context (repo map)
         await a.init();
+        // Show project rules in banner
+        const rulesSource = a.getProjectRulesSource();
+        if (rulesSource) {
+            info.push(`📋 ${rulesSource} loaded`);
+            setConnectionInfo([...info]);
+        }
         setAgent(a);
         setModelName(provider.model);
         providerRef.current = { baseUrl: provider.baseUrl, apiKey: provider.apiKey };
@@ -287,7 +303,7 @@ function App() {
                 // Commands that need args (like /commit, /model) — fill input instead of executing
                 if (selected.cmd === "/commit" || selected.cmd === "/model" || selected.cmd === "/session delete" ||
                     selected.cmd === "/skills install" || selected.cmd === "/skills remove" || selected.cmd === "/skills search" ||
-                    selected.cmd === "/skills on" || selected.cmd === "/skills off") {
+                    selected.cmd === "/skills on" || selected.cmd === "/skills off" || selected.cmd === "/architect") {
                     setInput(selected.cmd + " ");
                     setCmdIndex(0);
                     setInputKey((k) => k + 1);
@@ -347,6 +363,10 @@ function App() {
                 "  /git on    — enable auto-commits",
                 "  /git off   — disable auto-commits",
                 "  /skills    — manage skill packs",
+                "  /architect — toggle architect mode (plan then execute)",
+                "  /lint      — show auto-lint status & detected linter",
+                "  /lint on   — enable auto-lint",
+                "  /lint off  — disable auto-lint",
                 "  /quit      — exit",
             ].join("\n"));
             return;
@@ -455,6 +475,65 @@ function App() {
             addMsg("info", `✅ Switched to theme: ${THEMES[themeName].name}`);
             return;
         }
+        // ── Architect commands (work without agent) ──
+        if (trimmed === "/architect") {
+            if (!agent) {
+                addMsg("info", "🏗️ Architect mode: no agent connected. Connect first with /login or /connect.");
+                return;
+            }
+            const current = agent.getArchitectModel();
+            if (current) {
+                agent.setArchitectModel(null);
+                addMsg("info", "🏗️ Architect mode OFF");
+            }
+            else {
+                // Use config default or a sensible default
+                const defaultModel = loadConfig().defaults.architectModel || agent.getModel();
+                agent.setArchitectModel(defaultModel);
+                addMsg("info", `🏗️ Architect mode ON (planner: ${defaultModel})`);
+            }
+            return;
+        }
+        if (trimmed.startsWith("/architect ")) {
+            const model = trimmed.replace("/architect ", "").trim();
+            if (!model) {
+                addMsg("info", "Usage: /architect <model> or /architect to toggle");
+                return;
+            }
+            if (agent) {
+                agent.setArchitectModel(model);
+                addMsg("info", `🏗️ Architect mode ON (planner: ${model})`);
+            }
+            else {
+                addMsg("info", "⚠ No agent connected. Connect first.");
+            }
+            return;
+        }
+        // ── Lint commands (work without agent) ──
+        if (trimmed === "/lint") {
+            const { detectLinter } = await import("./utils/lint.js");
+            const linter = detectLinter(process.cwd());
+            const enabled = agent ? agent.isAutoLintEnabled() : true;
+            if (linter) {
+                addMsg("info", `🔍 Auto-lint: ${enabled ? "ON" : "OFF"}\n  Detected: ${linter.name}\n  Command: ${linter.command} <file>`);
+            }
+            else {
+                addMsg("info", `🔍 Auto-lint: ${enabled ? "ON" : "OFF"}\n  No linter detected in this project.`);
+            }
+            return;
+        }
+        if (trimmed === "/lint on") {
+            if (agent)
+                agent.setAutoLint(true);
+            addMsg("info", "🔍 Auto-lint ON");
+            return;
+        }
+        if (trimmed === "/lint off") {
+            if (agent)
+                agent.setAutoLint(false);
+            addMsg("info", "🔍 Auto-lint OFF");
+            return;
+        }
         // Commands below require an active LLM connection
         if (!agent) {
             addMsg("info", "⚠ No LLM connected. Use /login to authenticate with a provider, or start a local server.");
@@ -641,8 +720,8 @@ function App() {
         setSpinnerMsg(SPINNER_MESSAGES[Math.floor(Math.random() * SPINNER_MESSAGES.length)]);
         try {
             // Response is built incrementally via onToken callback
-            // chat() returns the final text but we don't need to add it again
-            await agent.chat(trimmed);
+            // send() routes through architect if enabled, otherwise direct chat
+            await agent.send(trimmed);
         }
         catch (err) {
             addMsg("error", `Error: ${err.message}`);
@@ -1192,7 +1271,7 @@ function App() {
                         })(), modelName ? ` · 🤖 ${modelName}` : "", (() => {
                             const count = getActiveSkillCount(process.cwd(), sessionDisabledSkills);
                             return count > 0 ? ` · 🧠 ${count} skill${count !== 1 ? "s" : ""}` : "";
-                        })()] }) }))] }));
+                        })(), agent.getArchitectModel() ? " · 🏗️ architect" : ""] }) }))] }));
 }
 // Clear screen before render
 process.stdout.write("\x1B[2J\x1B[3J\x1B[H");

package/dist/utils/context.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Load project rules from CODEMAXXING.md, .codemaxxing/CODEMAXXING.md, or .cursorrules
+ * Returns { content, source } or null if none found
+ */
+export declare function loadProjectRules(cwd: string): {
+    content: string;
+    source: string;
+} | null;
 /**
  * Build a project context string by scanning the working directory
  */
@@ -5,7 +13,7 @@ export declare function buildProjectContext(cwd: string): Promise<string>;
 /**
  * Get the system prompt for the coding agent
  */
-export declare function getSystemPrompt(projectContext: string, skillPrompts?: string): Promise<string>;
+export declare function getSystemPrompt(projectContext: string, skillPrompts?: string, projectRules?: string): Promise<string>;
 /**
  * Synchronous version for backwards compatibility (without repo map)
  * @deprecated Use async buildProjectContext instead

package/dist/utils/context.js

@@ -1,6 +1,30 @@
 import { existsSync, readFileSync, readdirSync, statSync } from "fs";
 import { join } from "path";
 import { buildRepoMap } from "./repomap.js";
+/**
+ * Load project rules from CODEMAXXING.md, .codemaxxing/CODEMAXXING.md, or .cursorrules
+ * Returns { content, source } or null if none found
+ */
+export function loadProjectRules(cwd) {
+    const candidates = [
+        { path: join(cwd, "CODEMAXXING.md"), source: "CODEMAXXING.md" },
+        { path: join(cwd, ".codemaxxing", "CODEMAXXING.md"), source: ".codemaxxing/CODEMAXXING.md" },
+        { path: join(cwd, ".cursorrules"), source: ".cursorrules" },
+    ];
+    for (const { path, source } of candidates) {
+        if (existsSync(path)) {
+            try {
+                const content = readFileSync(path, "utf-8").trim();
+                if (content)
+                    return { content, source };
+            }
+            catch {
+                // skip unreadable files
+            }
+        }
+    }
+    return null;
+}
 /**
  * Build a project context string by scanning the working directory
  */
@@ -26,14 +50,6 @@ export async function buildProjectContext(cwd) {
     if (found.length > 0) {
         lines.push(`Project files: ${found.join(", ")}`);
     }
-    // Read PIERRE.md if it exists (like QWEN.md — project context file)
-    const contextMd = join(cwd, "CODEMAXXING.md");
-    if (existsSync(contextMd)) {
-        const content = readFileSync(contextMd, "utf-8");
-        lines.push("\n--- CODEMAXXING.md (project context) ---");
-        lines.push(content.slice(0, 4000));
-        lines.push("--- end CODEMAXXING.md ---");
-    }
     // Read package.json for project info
     const pkgPath = join(cwd, "package.json");
     if (existsSync(pkgPath)) {
@@ -86,7 +102,7 @@ export async function buildProjectContext(cwd) {
 /**
  * Get the system prompt for the coding agent
  */
-export async function getSystemPrompt(projectContext, skillPrompts = "") {
+export async function getSystemPrompt(projectContext, skillPrompts = "", projectRules = "") {
     const base = `You are CODEMAXXING, an AI coding assistant running in the terminal.
 
 You help developers understand, write, debug, and refactor code. You have access to tools that let you read files, write files, list directories, search code, and run shell commands.
@@ -111,10 +127,14 @@ ${projectContext}
 - Use code blocks with language tags
 - Be direct and helpful
 - If the user asks to "just do it", skip explanations and execute`;
+    let prompt = base;
+    if (projectRules) {
+        prompt += "\n\n--- Project Rules (CODEMAXXING.md) ---\n" + projectRules + "\n--- End Project Rules ---";
+    }
     if (skillPrompts) {
-        return base + "\n\n## Active Skills\n" + skillPrompts;
+        prompt += "\n\n## Active Skills\n" + skillPrompts;
     }
-    return base;
+    return prompt;
 }
 /**
  * Synchronous version for backwards compatibility (without repo map)

package/dist/utils/lint.d.ts

@@ -0,0 +1,13 @@
+interface LinterInfo {
+    name: string;
+    command: string;
+}
+/**
+ * Detect the project linter based on config files in the working directory
+ */
+export declare function detectLinter(cwd: string): LinterInfo | null;
+/**
+ * Run the linter on a specific file and return errors (or null if clean)
+ */
+export declare function runLinter(linter: LinterInfo, filePath: string, cwd: string): string | null;
+export {};

package/dist/utils/lint.js

@@ -0,0 +1,108 @@
+import { existsSync } from "fs";
+import { join, extname } from "path";
+import { execSync } from "child_process";
+/**
+ * Detect the project linter based on config files in the working directory
+ */
+export function detectLinter(cwd) {
+    // JavaScript/TypeScript — check for biome first (faster), then eslint
+    if (existsSync(join(cwd, "biome.json")) || existsSync(join(cwd, "biome.jsonc"))) {
+        return { name: "Biome", command: "npx biome check" };
+    }
+    if (existsSync(join(cwd, ".eslintrc")) ||
+        existsSync(join(cwd, ".eslintrc.js")) ||
+        existsSync(join(cwd, ".eslintrc.cjs")) ||
+        existsSync(join(cwd, ".eslintrc.json")) ||
+        existsSync(join(cwd, ".eslintrc.yml")) ||
+        existsSync(join(cwd, "eslint.config.js")) ||
+        existsSync(join(cwd, "eslint.config.mjs")) ||
+        existsSync(join(cwd, "eslint.config.ts"))) {
+        return { name: "ESLint", command: "npx eslint" };
+    }
+    // Check package.json for eslint dependency as fallback
+    if (existsSync(join(cwd, "package.json"))) {
+        try {
+            const pkg = JSON.parse(require("fs").readFileSync(join(cwd, "package.json"), "utf-8"));
+            const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+            if (allDeps["@biomejs/biome"]) {
+                return { name: "Biome", command: "npx biome check" };
+            }
+            if (allDeps["eslint"]) {
+                return { name: "ESLint", command: "npx eslint" };
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    // Python — ruff (fast) or flake8/pylint
+    if (existsSync(join(cwd, "ruff.toml")) || existsSync(join(cwd, ".ruff.toml"))) {
+        return { name: "Ruff", command: "ruff check" };
+    }
+    if (existsSync(join(cwd, "pyproject.toml"))) {
+        try {
+            const content = require("fs").readFileSync(join(cwd, "pyproject.toml"), "utf-8");
+            if (content.includes("[tool.ruff]")) {
+                return { name: "Ruff", command: "ruff check" };
+            }
+        }
+        catch {
+            // ignore
+        }
+        return { name: "Ruff", command: "ruff check" };
+    }
+    // Rust
+    if (existsSync(join(cwd, "Cargo.toml"))) {
+        return { name: "Clippy", command: "cargo clippy --message-format=short --" };
+    }
+    // Go
+    if (existsSync(join(cwd, "go.mod"))) {
+        return { name: "golangci-lint", command: "golangci-lint run" };
+    }
+    return null;
+}
+/**
+ * Run the linter on a specific file and return errors (or null if clean)
+ */
+export function runLinter(linter, filePath, cwd) {
+    // Skip files that the linter can't handle
+    const ext = extname(filePath).toLowerCase();
+    const jsExts = new Set([".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".mts", ".cts"]);
+    const pyExts = new Set([".py", ".pyi"]);
+    const rsExts = new Set([".rs"]);
+    const goExts = new Set([".go"]);
+    // Only lint files matching the linter's language
+    if ((linter.name === "ESLint" || linter.name === "Biome") && !jsExts.has(ext))
+        return null;
+    if (linter.name === "Ruff" && !pyExts.has(ext))
+        return null;
+    if (linter.name === "Clippy" && !rsExts.has(ext))
+        return null;
+    if (linter.name === "golangci-lint" && !goExts.has(ext))
+        return null;
+    try {
+        // Clippy works on the whole project, not individual files
+        const command = linter.name === "Clippy"
+            ? linter.command
+            : `${linter.command} ${filePath}`;
+        execSync(command, {
+            cwd,
+            encoding: "utf-8",
+            timeout: 15000,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        return null; // No errors
+    }
+    catch (e) {
+        const output = (e.stdout || "") + (e.stderr || "");
+        const trimmed = output.trim();
+        if (!trimmed)
+            return null;
+        // Limit output to avoid flooding context
+        const lines = trimmed.split("\n");
+        if (lines.length > 30) {
+            return lines.slice(0, 30).join("\n") + `\n... (${lines.length - 30} more lines)`;
+        }
+        return trimmed;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codemaxxing",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Open-source terminal coding agent. Connect any LLM. Max your code.",
   "main": "dist/index.js",
   "bin": {

package/src/agent.ts

@@ -6,7 +6,8 @@ import type {
   ChatCompletionChunk,
 } from "openai/resources/chat/completions";
 import { FILE_TOOLS, executeTool, generateDiff, getExistingContent } from "./tools/files.js";
-import { buildProjectContext, getSystemPrompt } from "./utils/context.js";
+import { detectLinter, runLinter } from "./utils/lint.js";
+import { buildProjectContext, getSystemPrompt, loadProjectRules } from "./utils/context.js";
 import { isGitRepo, autoCommit } from "./utils/git.js";
 import { buildSkillPrompts, getActiveSkillCount } from "./utils/skills.js";
 import { createSession, saveMessage, updateTokenEstimate, updateSessionCost, loadMessages } from "./utils/sessions.js";
@@ -71,6 +72,8 @@ export interface AgentOptions {
   onToolApproval?: (name: string, args: Record<string, unknown>, diff?: string) => Promise<"yes" | "no" | "always">;
   onGitCommit?: (message: string) => void;
   onContextCompressed?: (oldTokens: number, newTokens: number) => void;
+  onArchitectPlan?: (plan: string) => void;
+  onLintResult?: (file: string, errors: string) => void;
   contextCompressionThreshold?: number;
 }
 
@@ -101,6 +104,10 @@ export class CodingAgent {
   private systemPrompt: string = "";
   private compressionThreshold: number;
   private sessionDisabledSkills: Set<string> = new Set();
+  private projectRulesSource: string | null = null;
+  private architectModel: string | null = null;
+  private autoLintEnabled: boolean = true;
+  private detectedLinter: { command: string; name: string } | null = null;
 
   constructor(private options: AgentOptions) {
     this.providerType = options.provider.type || "openai";
@@ -131,7 +138,12 @@ export class CodingAgent {
   async init(): Promise<void> {
     const context = await buildProjectContext(this.cwd);
     const skillPrompts = buildSkillPrompts(this.cwd, this.sessionDisabledSkills);
-    this.systemPrompt = await getSystemPrompt(context, skillPrompts);
+    const rules = loadProjectRules(this.cwd);
+    if (rules) this.projectRulesSource = rules.source;
+    this.systemPrompt = await getSystemPrompt(context, skillPrompts, rules?.content ?? "");
+
+    // Detect project linter
+    this.detectedLinter = detectLinter(this.cwd);
 
     this.messages = [
       { role: "system", content: this.systemPrompt },
@@ -174,6 +186,16 @@ export class CodingAgent {
     return this.repoMap;
   }
 
+  /**
+   * Send a message, routing through architect model if enabled
+   */
+  async send(userMessage: string): Promise<string> {
+    if (this.architectModel) {
+      return this.architectChat(userMessage);
+    }
+    return this.chat(userMessage);
+  }
+
   /**
    * Stream a response from the model.
    * Assembles tool call chunks, emits tokens in real-time,
@@ -347,6 +369,23 @@ export class CodingAgent {
           }
         }
 
+        // Auto-lint after successful write_file
+        if (this.autoLintEnabled && this.detectedLinter && toolCall.name === "write_file" && result.startsWith("✅")) {
+          const filePath = String(args.path ?? "");
+          const lintErrors = runLinter(this.detectedLinter, filePath, this.cwd);
+          if (lintErrors) {
+            this.options.onLintResult?.(filePath, lintErrors);
+            const lintMsg: ChatCompletionMessageParam = {
+              role: "tool",
+              tool_call_id: toolCall.id,
+              content: result + `\n\nLint errors detected in ${filePath}:\n${lintErrors}\nPlease fix these issues.`,
+            };
+            this.messages.push(lintMsg);
+            saveMessage(this.sessionId, lintMsg);
+            continue; // skip the normal tool message push
+          }
+        }
+
         const toolMsg: ChatCompletionMessageParam = {
           role: "tool",
           tool_call_id: toolCall.id,
@@ -542,6 +581,23 @@ export class CodingAgent {
           }
         }
 
+        // Auto-lint after successful write_file
+        if (this.autoLintEnabled && this.detectedLinter && toolCall.name === "write_file" && result.startsWith("✅")) {
+          const filePath = String(args.path ?? "");
+          const lintErrors = runLinter(this.detectedLinter, filePath, this.cwd);
+          if (lintErrors) {
+            this.options.onLintResult?.(filePath, lintErrors);
+            const lintMsg: ChatCompletionMessageParam = {
+              role: "tool",
+              tool_call_id: toolCall.id,
+              content: result + `\n\nLint errors detected in ${filePath}:\n${lintErrors}\nPlease fix these issues.`,
+            };
+            this.messages.push(lintMsg);
+            saveMessage(this.sessionId, lintMsg);
+            continue;
+          }
+        }
+
         const toolMsg: ChatCompletionMessageParam = {
           role: "tool",
           tool_call_id: toolCall.id,
@@ -712,6 +768,72 @@ export class CodingAgent {
     return this.cwd;
   }
 
+  getProjectRulesSource(): string | null {
+    return this.projectRulesSource;
+  }
+
+  setArchitectModel(model: string | null): void {
+    this.architectModel = model;
+  }
+
+  getArchitectModel(): string | null {
+    return this.architectModel;
+  }
+
+  setAutoLint(enabled: boolean): void {
+    this.autoLintEnabled = enabled;
+  }
+
+  isAutoLintEnabled(): boolean {
+    return this.autoLintEnabled;
+  }
+
+  getDetectedLinter(): { command: string; name: string } | null {
+    return this.detectedLinter;
+  }
+
+  setDetectedLinter(linter: { command: string; name: string } | null): void {
+    this.detectedLinter = linter;
+  }
+
+  /**
+   * Run the architect model to generate a plan, then feed to editor model
+   */
+  private async architectChat(userMessage: string): Promise<string> {
+    const architectSystemPrompt = "You are a senior software architect. Analyze the request and create a detailed implementation plan. List exactly which files to modify, what changes to make, and in what order. Do NOT write code — just plan.";
+
+    let plan = "";
+
+    if (this.providerType === "anthropic" && this.anthropicClient) {
+      const response = await this.anthropicClient.messages.create({
+        model: this.architectModel!,
+        max_tokens: this.maxTokens,
+        system: architectSystemPrompt,
+        messages: [{ role: "user", content: userMessage }],
+      });
+      plan = response.content
+        .filter((b): b is Anthropic.TextBlock => b.type === "text")
+        .map((b) => b.text)
+        .join("");
+    } else {
+      const response = await this.client.chat.completions.create({
+        model: this.architectModel!,
+        max_tokens: this.maxTokens,
+        messages: [
+          { role: "system", content: architectSystemPrompt },
+          { role: "user", content: userMessage },
+        ],
+      });
+      plan = response.choices[0]?.message?.content ?? "(no plan generated)";
+    }
+
+    this.options.onArchitectPlan?.(plan);
+
+    // Feed plan + original request to the editor model
+    const editorPrompt = `## Architect Plan\n${plan}\n\n## Original Request\n${userMessage}\n\nExecute the plan above. Follow it step by step.`;
+    return this.chat(editorPrompt);
+  }
+
   reset(): void {
     const systemMsg = this.messages[0];
     this.messages = [systemMsg];

package/src/cli.ts

@@ -2,7 +2,7 @@
 
 /**
  * Codemaxxing CLI entry point
- * Routes subcommands (login, auth) to auth-cli, everything else to the TUI
+ * Routes subcommands (login, auth, exec) to handlers, everything else to the TUI
  */
 
 import { spawn } from "node:child_process";
@@ -27,6 +27,10 @@ if (subcmd === "login" || subcmd === "auth") {
   });
 
   child.on("exit", (code) => process.exit(code ?? 0));
+} else if (subcmd === "exec") {
+  // Headless/CI mode — no TUI
+  const { runExec } = await import("./exec.js");
+  await runExec(process.argv.slice(3));
 } else {
   // TUI mode — import directly (not spawn) to preserve raw stdin
   await import("./index.js");

package/src/config.ts

@@ -22,6 +22,8 @@ export interface CodemaxxingConfig {
     contextFiles: number;
     maxTokens: number;
     contextCompressionThreshold?: number;
+    architectModel?: string;
+    autoLint?: boolean;
   };
 }
 
@@ -85,6 +87,7 @@ codemaxxing — your code. your model. no excuses.
 
 Usage:
   codemaxxing [options]
+  codemaxxing exec "prompt" [exec-options]
 
 Options:
   -m, --model <model>       Model name to use
@@ -93,11 +96,19 @@ Options:
   -u, --base-url <url>      Base URL for the provider API
   -h, --help                Show this help
 
+Exec options (headless/CI mode):
+  --auto-approve            Skip tool approval prompts
+  --json                    Output JSON instead of streaming text
+  -m, --model <model>       Model to use
+  -p, --provider <name>     Provider profile
+
 Examples:
   codemaxxing                                    # Auto-detect local LLM
   codemaxxing -m gpt-4o -u https://api.openai.com/v1 -k sk-...
   codemaxxing -p openrouter                      # Use saved provider profile
   codemaxxing -m qwen3.5-35b                     # Override model only
+  codemaxxing exec "fix the failing tests"       # Headless mode
+  echo "explain this code" | codemaxxing exec    # Pipe input
 
 Config: ~/.codemaxxing/settings.json
 `);