codemaxxing 0.2.0 → 0.3.0

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.0",
+  "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
 `);

package/src/exec.ts

@@ -0,0 +1,171 @@
+/**
+ * Headless/CI execution mode — runs agent without TUI
+ * Usage: codemaxxing exec "your prompt here"
+ * Flags: --auto-approve, --json, --model <model>, --provider <name>
+ * Supports stdin pipe: echo "fix the tests" | codemaxxing exec
+ */
+
+import { CodingAgent } from "./agent.js";
+import { loadConfig, applyOverrides, detectLocalProvider } from "./config.js";
+import { getCredential } from "./utils/auth.js";
+
+interface ExecArgs {
+  prompt: string;
+  autoApprove: boolean;
+  json: boolean;
+  model?: string;
+  provider?: string;
+}
+
+function parseExecArgs(argv: string[]): ExecArgs {
+  const args: ExecArgs = {
+    prompt: "",
+    autoApprove: false,
+    json: false,
+  };
+
+  const positional: string[] = [];
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = argv[i + 1];
+
+    if (arg === "--auto-approve") {
+      args.autoApprove = true;
+    } else if (arg === "--json") {
+      args.json = true;
+    } else if ((arg === "--model" || arg === "-m") && next) {
+      args.model = next;
+      i++;
+    } else if ((arg === "--provider" || arg === "-p") && next) {
+      args.provider = next;
+      i++;
+    } else if (!arg.startsWith("-")) {
+      positional.push(arg);
+    }
+  }
+
+  args.prompt = positional.join(" ");
+  return args;
+}
+
+async function readStdin(): Promise<string> {
+  // Check if stdin has data (piped input)
+  if (process.stdin.isTTY) return "";
+
+  return new Promise((resolve) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => { data += chunk; });
+    process.stdin.on("end", () => resolve(data.trim()));
+    // Timeout after 1s if no data arrives
+    setTimeout(() => resolve(data.trim()), 1000);
+  });
+}
+
+export async function runExec(argv: string[]): Promise<void> {
+  const args = parseExecArgs(argv);
+
+  // Read from stdin if no prompt provided
+  if (!args.prompt) {
+    args.prompt = await readStdin();
+  }
+
+  if (!args.prompt) {
+    process.stderr.write("Error: No prompt provided.\n");
+    process.stderr.write("Usage: codemaxxing exec \"your prompt here\"\n");
+    process.stderr.write("       echo \"fix tests\" | codemaxxing exec\n");
+    process.stderr.write("\nFlags:\n");
+    process.stderr.write("  --auto-approve   Skip approval prompts\n");
+    process.stderr.write("  --json           JSON output\n");
+    process.stderr.write("  -m, --model      Model to use\n");
+    process.stderr.write("  -p, --provider   Provider profile\n");
+    process.exit(1);
+  }
+
+  // Resolve provider config
+  const rawConfig = loadConfig();
+  const cliArgs = {
+    model: args.model,
+    provider: args.provider,
+  };
+  const config = applyOverrides(rawConfig, cliArgs);
+  let provider = config.provider;
+
+  // Auto-detect local provider if needed
+  if (provider.model === "auto" || (provider.baseUrl === "http://localhost:1234/v1" && !args.provider)) {
+    const detected = await detectLocalProvider();
+    if (detected) {
+      if (args.model) detected.model = args.model;
+      provider = detected;
+    } else if (!args.provider) {
+      process.stderr.write("Error: No LLM provider found. Start a local server or use --provider.\n");
+      process.exit(1);
+    }
+  }
+
+  process.stderr.write(`Provider: ${provider.baseUrl}\n`);
+  process.stderr.write(`Model: ${provider.model}\n`);
+  process.stderr.write(`Prompt: ${args.prompt.slice(0, 100)}${args.prompt.length > 100 ? "..." : ""}\n`);
+  process.stderr.write("---\n");
+
+  const cwd = process.cwd();
+  let hasChanges = false;
+  let fullResponse = "";
+  const toolResults: Array<{ tool: string; args: Record<string, unknown>; result: string }> = [];
+
+  const agent = new CodingAgent({
+    provider,
+    cwd,
+    maxTokens: config.defaults.maxTokens,
+    autoApprove: args.autoApprove,
+    onToken: (token) => {
+      if (!args.json) {
+        process.stdout.write(token);
+      }
+      fullResponse += token;
+    },
+    onToolCall: (name, toolArgs) => {
+      process.stderr.write(`Tool: ${name}(${Object.values(toolArgs).map(v => String(v).slice(0, 60)).join(", ")})\n`);
+      if (name === "write_file") hasChanges = true;
+    },
+    onToolResult: (name, result) => {
+      const lines = result.split("\n").length;
+      process.stderr.write(`  └ ${lines} lines\n`);
+      toolResults.push({ tool: name, args: {}, result });
+    },
+    onToolApproval: async (name, toolArgs, diff) => {
+      if (args.autoApprove) return "yes";
+      // In non-interactive mode without auto-approve, deny dangerous tools
+      process.stderr.write(`⚠ Denied ${name} (use --auto-approve to allow)\n`);
+      return "no";
+    },
+  });
+
+  try {
+    await agent.init();
+    await agent.send(args.prompt);
+
+    if (!args.json) {
+      // Ensure newline at end of output
+      process.stdout.write("\n");
+    } else {
+      // JSON output mode
+      const output = {
+        response: fullResponse,
+        model: provider.model,
+        tools_used: toolResults.length,
+        has_changes: hasChanges,
+      };
+      process.stdout.write(JSON.stringify(output, null, 2) + "\n");
+    }
+
+    process.exit(hasChanges ? 0 : 2);
+  } catch (err: any) {
+    process.stderr.write(`Error: ${err.message}\n`);
+    if (args.json) {
+      process.stdout.write(JSON.stringify({ error: err.message }, null, 2) + "\n");
+    }
+    process.exit(1);
+  }
+}