codemaxxing 0.2.1 → 0.3.0

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);
+  }
+}

package/src/index.tsx

@@ -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" },
 ];
 
@@ -277,6 +281,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) => {
@@ -289,6 +299,13 @@ 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 };
@@ -336,7 +353,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);
@@ -398,6 +415,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;
@@ -502,6 +523,62 @@ 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.");
@@ -684,8 +761,8 @@ function App() {
 
     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: any) {
       addMsg("error", `Error: ${err.message}`);
     }
@@ -1497,6 +1574,7 @@ function App() {
               const count = getActiveSkillCount(process.cwd(), sessionDisabledSkills);
               return count > 0 ? ` · 🧠 ${count} skill${count !== 1 ? "s" : ""}` : "";
             })()}
+            {agent.getArchitectModel() ? " · 🏗️ architect" : ""}
           </Text>
         </Box>
       )}

package/src/utils/context.ts

@@ -3,6 +3,30 @@ import { join, extname } from "path";
 import { buildRepoMap } from "./repomap.js";
 import { buildSkillPrompts } from "./skills.js";
 
+/**
+ * Load project rules from CODEMAXXING.md, .codemaxxing/CODEMAXXING.md, or .cursorrules
+ * Returns { content, source } or null if none found
+ */
+export function loadProjectRules(cwd: string): { content: string; source: string } | null {
+  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
  */
@@ -31,15 +55,6 @@ export async function buildProjectContext(cwd: string): Promise<string> {
     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)) {
@@ -94,7 +109,7 @@ export async function buildProjectContext(cwd: string): Promise<string> {
 /**
  * Get the system prompt for the coding agent
  */
-export async function getSystemPrompt(projectContext: string, skillPrompts: string = ""): Promise<string> {
+export async function getSystemPrompt(projectContext: string, skillPrompts: string = "", projectRules: string = ""): Promise<string> {
   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.
@@ -120,10 +135,17 @@ ${projectContext}
 - 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;
 }
 
 /**

package/src/utils/lint.ts

@@ -0,0 +1,116 @@
+import { existsSync } from "fs";
+import { join, extname } from "path";
+import { execSync } from "child_process";
+
+interface LinterInfo {
+  name: string;
+  command: string;
+}
+
+/**
+ * Detect the project linter based on config files in the working directory
+ */
+export function detectLinter(cwd: string): LinterInfo | null {
+  // 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: LinterInfo, filePath: string, cwd: string): string | null {
+  // 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: any) {
+    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;
+  }
+}