codemaxxing 0.1.0

package/dist/tools/files.js

@@ -0,0 +1,227 @@
+import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from "fs";
+import { join, relative } from "path";
+/**
+ * Tool definitions for the OpenAI function calling API
+ */
+export const FILE_TOOLS = [
+    {
+        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, args, cwd) {
+    switch (name) {
+        case "read_file": {
+            const filePath = join(cwd, args.path);
+            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);
+            try {
+                writeFileSync(filePath, args.content, "utf-8");
+                return `✅ Wrote ${args.content.length} bytes to ${args.path}`;
+            }
+            catch (e) {
+                return `Error writing file: ${e}`;
+            }
+        }
+        case "list_files": {
+            const dirPath = join(cwd, args.path || ".");
+            if (!existsSync(dirPath))
+                return `Error: Directory not found: ${args.path}`;
+            try {
+                const entries = listDir(dirPath, cwd, args.recursive);
+                return entries.join("\n");
+            }
+            catch (e) {
+                return `Error listing files: ${e}`;
+            }
+        }
+        case "search_files": {
+            const searchPath = join(cwd, args.path || ".");
+            try {
+                return searchInFiles(searchPath, args.pattern, cwd);
+            }
+            catch (e) {
+                return `Error searching: ${e}`;
+            }
+        }
+        case "run_command": {
+            try {
+                const { execSync } = await import("child_process");
+                const output = execSync(args.command, {
+                    cwd,
+                    encoding: "utf-8",
+                    timeout: 30000,
+                    maxBuffer: 1024 * 1024,
+                });
+                return output || "(no output)";
+            }
+            catch (e) {
+                return `Command failed: ${e.stderr || e.message}`;
+            }
+        }
+        default:
+            return `Unknown tool: ${name}`;
+    }
+}
+function listDir(dirPath, cwd, recursive = false, depth = 0) {
+    const entries = [];
+    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, pattern, cwd) {
+    const results = [];
+    const IGNORE = ["node_modules", ".git", "dist", ".next", "__pycache__"];
+    const regex = new RegExp(pattern, "gi");
+    function search(dir) {
+        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/dist/utils/context.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Build a project context string by scanning the working directory
+ */
+export declare function buildProjectContext(cwd: string): Promise<string>;
+/**
+ * Get the system prompt for the coding agent
+ */
+export declare function getSystemPrompt(projectContext: string): Promise<string>;
+/**
+ * Synchronous version for backwards compatibility (without repo map)
+ * @deprecated Use async buildProjectContext instead
+ */
+export declare function buildProjectContextSync(cwd: string): string;

package/dist/utils/context.js

@@ -0,0 +1,135 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { join } from "path";
+import { buildRepoMap } from "./repomap.js";
+/**
+ * Build a project context string by scanning the working directory
+ */
+export async function buildProjectContext(cwd) {
+    const lines = [];
+    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 = [];
+    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) {
+    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) {
+    const lines = [];
+    lines.push(`Project root: ${cwd}`);
+    const markers = [
+        "package.json", "Cargo.toml", "pyproject.toml", "go.mod",
+        "Makefile", "Dockerfile", "README.md", "CODEMAXXING.md",
+    ];
+    const found = [];
+    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/dist/utils/git.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Check if a directory is inside a git repo
+ */
+export declare function isGitRepo(cwd: string): boolean;
+/**
+ * Get current branch name
+ */
+export declare function getBranch(cwd: string): string;
+/**
+ * Get short git status (clean / dirty + count)
+ */
+export declare function getStatus(cwd: string): string;
+/**
+ * Auto-commit a file change with a descriptive message
+ */
+export declare function autoCommit(cwd: string, filePath: string, action: string): boolean;
+/**
+ * Get diff of uncommitted changes (or last commit)
+ */
+export declare function getDiff(cwd: string): string;
+/**
+ * Undo the last codemaxxing commit
+ */
+export declare function undoLastCommit(cwd: string): {
+    success: boolean;
+    message: string;
+};

package/dist/utils/git.js

@@ -0,0 +1,113 @@
+import { execSync } from "child_process";
+/**
+ * Check if a directory is inside a git repo
+ */
+export function isGitRepo(cwd) {
+    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) {
+    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) {
+    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, filePath, action) {
+    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) {
+    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) {
+    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) {
+        return { success: false, message: `Error: ${e.message}` };
+    }
+}

package/dist/utils/repomap.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Build the repo map — cached for 1 min
+ */
+export declare function buildRepoMap(cwd: string): Promise<string>;
+/**
+ * Get cached map without rebuilding
+ */
+export declare function getCachedMap(): string;
+/**
+ * Clear the cache
+ */
+export declare function clearMapCache(): void;
+/**
+ * Check if file is supported
+ */
+export declare function isSupportedFile(filePath: string): boolean;
+export declare function getSupportedExtensions(): string[];
+export declare function getLanguageForExt(ext: string): string | null;