codemaxxing 0.1.0

package/src/tools/files.ts

@@ -0,0 +1,247 @@
+import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from "fs";
+import { join, relative } from "path";
+import type { ChatCompletionTool } from "openai/resources/chat/completions";
+
+/**
+ * Tool definitions for the OpenAI function calling API
+ */
+export const FILE_TOOLS: ChatCompletionTool[] = [
+  {
+    type: "function",
+    function: {
+      name: "read_file",
+      description: "Read the contents of a file at the given path",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "Path to the file to read (relative to project root)",
+          },
+        },
+        required: ["path"],
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "write_file",
+      description:
+        "Write content to a file. Creates the file if it doesn't exist, overwrites if it does.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "Path to the file to write (relative to project root)",
+          },
+          content: {
+            type: "string",
+            description: "Content to write to the file",
+          },
+        },
+        required: ["path", "content"],
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "list_files",
+      description:
+        "List files and directories in the given path. Returns file names and types.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description:
+              "Directory path to list (relative to project root, defaults to '.')",
+          },
+          recursive: {
+            type: "boolean",
+            description: "Whether to list files recursively (default: false)",
+          },
+        },
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "search_files",
+      description: "Search for a text pattern across files in the project",
+      parameters: {
+        type: "object",
+        properties: {
+          pattern: {
+            type: "string",
+            description: "Text or regex pattern to search for",
+          },
+          path: {
+            type: "string",
+            description: "Directory to search in (defaults to project root)",
+          },
+        },
+        required: ["pattern"],
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "run_command",
+      description:
+        "Execute a shell command and return the output. Use for running tests, builds, linters, etc.",
+      parameters: {
+        type: "object",
+        properties: {
+          command: {
+            type: "string",
+            description: "Shell command to execute",
+          },
+        },
+        required: ["command"],
+      },
+    },
+  },
+];
+
+/**
+ * Execute a tool call and return the result
+ */
+export async function executeTool(
+  name: string,
+  args: Record<string, unknown>,
+  cwd: string
+): Promise<string> {
+  switch (name) {
+    case "read_file": {
+      const filePath = join(cwd, args.path as string);
+      if (!existsSync(filePath)) return `Error: File not found: ${args.path}`;
+      try {
+        return readFileSync(filePath, "utf-8");
+      } catch (e) {
+        return `Error reading file: ${e}`;
+      }
+    }
+
+    case "write_file": {
+      const filePath = join(cwd, args.path as string);
+      try {
+        writeFileSync(filePath, args.content as string, "utf-8");
+        return `✅ Wrote ${(args.content as string).length} bytes to ${args.path}`;
+      } catch (e) {
+        return `Error writing file: ${e}`;
+      }
+    }
+
+    case "list_files": {
+      const dirPath = join(cwd, (args.path as string) || ".");
+      if (!existsSync(dirPath)) return `Error: Directory not found: ${args.path}`;
+      try {
+        const entries = listDir(dirPath, cwd, args.recursive as boolean);
+        return entries.join("\n");
+      } catch (e) {
+        return `Error listing files: ${e}`;
+      }
+    }
+
+    case "search_files": {
+      const searchPath = join(cwd, (args.path as string) || ".");
+      try {
+        return searchInFiles(searchPath, args.pattern as string, cwd);
+      } catch (e) {
+        return `Error searching: ${e}`;
+      }
+    }
+
+    case "run_command": {
+      try {
+        const { execSync } = await import("child_process");
+        const output = execSync(args.command as string, {
+          cwd,
+          encoding: "utf-8",
+          timeout: 30000,
+          maxBuffer: 1024 * 1024,
+        });
+        return output || "(no output)";
+      } catch (e: any) {
+        return `Command failed: ${e.stderr || e.message}`;
+      }
+    }
+
+    default:
+      return `Unknown tool: ${name}`;
+  }
+}
+
+function listDir(
+  dirPath: string,
+  cwd: string,
+  recursive: boolean = false,
+  depth: number = 0
+): string[] {
+  const entries: string[] = [];
+  const IGNORE = ["node_modules", ".git", "dist", ".next", "__pycache__"];
+
+  for (const entry of readdirSync(dirPath)) {
+    if (IGNORE.includes(entry)) continue;
+    const fullPath = join(dirPath, entry);
+    const rel = relative(cwd, fullPath);
+    const stat = statSync(fullPath);
+    const prefix = "  ".repeat(depth);
+
+    if (stat.isDirectory()) {
+      entries.push(`${prefix}📁 ${rel}/`);
+      if (recursive && depth < 3) {
+        entries.push(...listDir(fullPath, cwd, true, depth + 1));
+      }
+    } else {
+      const size = stat.size > 1024 ? `${(stat.size / 1024).toFixed(1)}KB` : `${stat.size}B`;
+      entries.push(`${prefix}📄 ${rel} (${size})`);
+    }
+  }
+  return entries;
+}
+
+function searchInFiles(
+  dirPath: string,
+  pattern: string,
+  cwd: string
+): string {
+  const results: string[] = [];
+  const IGNORE = ["node_modules", ".git", "dist", ".next", "__pycache__"];
+  const regex = new RegExp(pattern, "gi");
+
+  function search(dir: string) {
+    for (const entry of readdirSync(dir)) {
+      if (IGNORE.includes(entry)) continue;
+      const fullPath = join(dir, entry);
+      const stat = statSync(fullPath);
+
+      if (stat.isDirectory()) {
+        search(fullPath);
+      } else if (stat.size < 100000) {
+        try {
+          const content = readFileSync(fullPath, "utf-8");
+          const lines = content.split("\n");
+          for (let i = 0; i < lines.length; i++) {
+            if (regex.test(lines[i])) {
+              results.push(`${relative(cwd, fullPath)}:${i + 1}: ${lines[i].trim()}`);
+            }
+            regex.lastIndex = 0;
+          }
+        } catch {
+          // skip binary files
+        }
+      }
+    }
+  }
+
+  search(dirPath);
+  return results.length > 0
+    ? results.slice(0, 50).join("\n")
+    : "No matches found.";
+}

package/src/utils/context.ts

@@ -0,0 +1,146 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { join, extname } from "path";
+import { buildRepoMap } from "./repomap.js";
+
+/**
+ * Build a project context string by scanning the working directory
+ */
+export async function buildProjectContext(cwd: string): Promise<string> {
+  const lines: string[] = [];
+  lines.push(`Project root: ${cwd}`);
+
+  // Check for common project files
+  const markers = [
+    "package.json",
+    "Cargo.toml",
+    "pyproject.toml",
+    "go.mod",
+    "Makefile",
+    "Dockerfile",
+    "README.md",
+    "CODEMAXXING.md",
+  ];
+
+  const found: string[] = [];
+  for (const m of markers) {
+    if (existsSync(join(cwd, m))) found.push(m);
+  }
+
+  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)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      lines.push(`\nProject: ${pkg.name ?? "unknown"} v${pkg.version ?? "0.0.0"}`);
+      if (pkg.description) lines.push(`Description: ${pkg.description}`);
+      if (pkg.scripts) {
+        lines.push(`Available scripts: ${Object.keys(pkg.scripts).join(", ")}`);
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  // Quick file tree (top level only)
+  lines.push("\nProject structure:");
+  const IGNORE = ["node_modules", ".git", "dist", ".next", "__pycache__", ".DS_Store"];
+  try {
+    const entries = readdirSync(cwd)
+      .filter((e) => !IGNORE.includes(e))
+      .slice(0, 30);
+
+    for (const entry of entries) {
+      const fullPath = join(cwd, entry);
+      const stat = statSync(fullPath);
+      if (stat.isDirectory()) {
+        const count = readdirSync(fullPath).filter(
+          (e) => !IGNORE.includes(e)
+        ).length;
+        lines.push(`  📁 ${entry}/ (${count} items)`);
+      } else {
+        lines.push(`  📄 ${entry}`);
+      }
+    }
+  } catch {
+    lines.push("  (could not read directory)");
+  }
+
+  // Build and append repo map
+  try {
+    const repoMap = await buildRepoMap(cwd);
+    lines.push("\n" + repoMap);
+  } catch (e) {
+    // Repo map failed — continue without it
+    lines.push("\n## Repository Map\n  (unable to build map)");
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Get the system prompt for the coding agent
+ */
+export async function getSystemPrompt(projectContext: string): Promise<string> {
+  return `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.
+
+## Rules
+- Always read relevant files before making changes
+- Explain what you're about to do before doing it
+- When writing files, show the user what will change
+- Be concise but thorough
+- If you're unsure, ask — don't guess
+- Use the run_command tool for building, testing, and linters
+- Never delete files without explicit confirmation
+
+## Repository Map
+The project context below includes a map of the codebase structure. Use this map to understand what files, functions, classes, and types exist where. Use read_file to see full implementations when needed.
+
+## Project Context
+${projectContext}
+
+## Behavior
+- Respond in markdown
+- Use code blocks with language tags
+- Be direct and helpful
+- If the user asks to "just do it", skip explanations and execute`;
+}
+
+/**
+ * Synchronous version for backwards compatibility (without repo map)
+ * @deprecated Use async buildProjectContext instead
+ */
+export function buildProjectContextSync(cwd: string): string {
+  const lines: string[] = [];
+  lines.push(`Project root: ${cwd}`);
+
+  const markers = [
+    "package.json", "Cargo.toml", "pyproject.toml", "go.mod",
+    "Makefile", "Dockerfile", "README.md", "CODEMAXXING.md",
+  ];
+
+  const found: string[] = [];
+  for (const m of markers) {
+    if (existsSync(join(cwd, m))) found.push(m);
+  }
+
+  if (found.length > 0) {
+    lines.push(`Project files: ${found.join(", ")}`);
+  }
+
+  return lines.join("\n");
+}

package/src/utils/git.ts

@@ -0,0 +1,117 @@
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+
+/**
+ * Check if a directory is inside a git repo
+ */
+export function isGitRepo(cwd: string): boolean {
+  try {
+    execSync("git rev-parse --is-inside-work-tree", {
+      cwd,
+      stdio: "pipe",
+      encoding: "utf-8",
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get current branch name
+ */
+export function getBranch(cwd: string): string {
+  try {
+    return execSync("git branch --show-current", {
+      cwd,
+      stdio: "pipe",
+      encoding: "utf-8",
+    }).trim();
+  } catch {
+    return "unknown";
+  }
+}
+
+/**
+ * Get short git status (clean / dirty + count)
+ */
+export function getStatus(cwd: string): string {
+  try {
+    const output = execSync("git status --porcelain", {
+      cwd,
+      stdio: "pipe",
+      encoding: "utf-8",
+    }).trim();
+    if (!output) return "clean";
+    const count = output.split("\n").length;
+    return `${count} changed`;
+  } catch {
+    return "unknown";
+  }
+}
+
+/**
+ * Auto-commit a file change with a descriptive message
+ */
+export function autoCommit(cwd: string, filePath: string, action: string): boolean {
+  try {
+    execSync(`git add "${filePath}"`, { cwd, stdio: "pipe" });
+    const msg = `codemaxxing: ${action} ${filePath}`;
+    execSync(`git commit -m "${msg}" --no-verify`, { cwd, stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get diff of uncommitted changes (or last commit)
+ */
+export function getDiff(cwd: string): string {
+  try {
+    // First try uncommitted changes
+    let diff = execSync("git diff", { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
+    // Include staged changes too
+    const staged = execSync("git diff --cached", { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
+    if (staged) diff = diff ? `${diff}\n${staged}` : staged;
+
+    // If no uncommitted changes, show last commit
+    if (!diff) {
+      diff = execSync("git diff HEAD~1 HEAD", { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
+      if (diff) return `(last commit)\n${diff}`;
+    }
+
+    return diff || "No changes.";
+  } catch {
+    return "Error getting diff.";
+  }
+}
+
+/**
+ * Undo the last codemaxxing commit
+ */
+export function undoLastCommit(cwd: string): { success: boolean; message: string } {
+  try {
+    // Check if last commit was from codemaxxing
+    const lastMsg = execSync("git log -1 --pretty=%s", {
+      cwd,
+      stdio: "pipe",
+      encoding: "utf-8",
+    }).trim();
+
+    if (!lastMsg.startsWith("codemaxxing:")) {
+      return {
+        success: false,
+        message: `Last commit is not from codemaxxing: "${lastMsg}"`,
+      };
+    }
+
+    execSync("git reset --soft HEAD~1", { cwd, stdio: "pipe" });
+    execSync("git restore --staged .", { cwd, stdio: "pipe" });
+
+    return { success: true, message: `Reverted: ${lastMsg}` };
+  } catch (e: any) {
+    return { success: false, message: `Error: ${e.message}` };
+  }
+}