editcodewithai 0.0.1 → 0.1.0

package/dist/benchmarks/models.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.models = void 0;
+exports.models = [
+    "anthropic/claude-3.7-sonnet",
+    "anthropic/claude-3.7-sonnet:thinking",
+    "google/gemini-2.0-flash-001",
+    "anthropic/claude-3.5-sonnet",
+    "deepseek/deepseek-r1",
+    "openai/o3-mini-high",
+    "openai/o3-mini",
+    "deepseek/deepseek-chat",
+    "qwen/qwen-2.5-72b-instruct",
+    "qwen/qwq-32b",
+    "anthropic/claude-3.5-haiku",
+    "qwen/qwen-2.5-7b-instruct",
+    "amazon/nova-micro-v1",
+    "meta-llama/llama-3.1-8b-instruct",
+    "meta-llama/llama-3.2-3b-instruct",
+    "meta-llama/llama-3.2-1b-instruct",
+];

package/dist/benchmarks/runner.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Runs "index.mjs" for a given challenge directory with Node and returns exit code.
+ */
+export declare function runNodeTest(challengeDir: string): number;

package/dist/benchmarks/runner.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runNodeTest = runNodeTest;
+const child_process_1 = require("child_process");
+/**
+ * Runs "index.mjs" for a given challenge directory with Node and returns exit code.
+ */
+function runNodeTest(challengeDir) {
+    const result = runNodeProcess(challengeDir);
+    logTestResult(challengeDir, result);
+    return result.status ?? 1; // If status is null, consider that a failure
+}
+/**
+ * Executes the Node.js process for a test
+ */
+function runNodeProcess(challengeDir) {
+    const child = (0, child_process_1.spawnSync)("node", ["index.mjs"], {
+        cwd: challengeDir,
+        encoding: "utf-8",
+    });
+    return {
+        status: child.status,
+        stdout: child.stdout,
+        stderr: child.stderr
+    };
+}
+/**
+ * Logs the test result to the console
+ */
+function logTestResult(challengeDir, result) {
+    console.log(`--- Running test in ${challengeDir} ---`);
+    console.log("stdout:\n", result.stdout.trim());
+    console.log("stderr:\n", result.stderr.trim());
+    console.log("exit code:", result.status, "\n");
+}

package/dist/benchmarks/types.d.ts

@@ -0,0 +1,16 @@
+import { VizFiles } from "@vizhub/viz-types";
+export interface Challenge {
+    name: string;
+    prompt: string;
+    files: VizFiles;
+}
+export interface ChallengeResult {
+    challenge: string;
+    model: string;
+    passFail: "pass" | "fail" | "error";
+}
+export interface TestRunResult {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+}

package/dist/benchmarks/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const index_1 = require("./index");
+const llm_1 = require("./benchmarks/llm");
+const computeInitialDocument_1 = require("./computeInitialDocument");
+const dotenv_1 = __importDefault(require("dotenv"));
+const fs = __importStar(require("fs/promises"));
+// Load environment variables
+dotenv_1.default.config();
+const program = new commander_1.Command();
+program
+    .name("editcode")
+    .description("Edit code files using AI")
+    .option("-p, --prompt <prompt>", "The instruction for editing the code")
+    .option("-d, --dir <directory>", "Directory to process", process.cwd())
+    .option("--dry-run", "Show changes without writing them", false)
+    .option("--model <model>", "OpenRouter model to use", "anthropic/claude-3.7-sonnet")
+    .action(async (options) => {
+    try {
+        // Get prompt from user if not provided as argument
+        if (!options.prompt) {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+            options.prompt = await new Promise((resolve) => {
+                rl.question("> ", (answer) => {
+                    rl.close();
+                    resolve(answer);
+                });
+            });
+        }
+        if (!options.prompt.trim()) {
+            console.error("Error: Prompt cannot be empty");
+            process.exit(1);
+        }
+        // Debug: Log environment
+        console.log('Environment variables:', {
+            OPENROUTER_API_KEY: process.env.OPENROUTER_API_KEY ? '[PRESENT]' : '[MISSING]',
+            NODE_ENV: process.env.NODE_ENV,
+            PATH: process.env.PATH?.substring(0, 50) + '...'
+        });
+        // Validate API key
+        const apiKey = process.env.OPENROUTER_API_KEY;
+        if (!apiKey) {
+            console.error("Error: OPENROUTER_API_KEY environment variable is required");
+            process.exit(1);
+        }
+        // Get absolute path
+        const fullPath = path.resolve(options.dir);
+        console.log(`Processing directory: ${fullPath}`);
+        // Use computeInitialDocument to get files (respects .ignore files)
+        const initialDocument = (0, computeInitialDocument_1.computeInitialDocument)({ fullPath });
+        // Convert to VizFiles format
+        const vizFiles = {};
+        Object.entries(initialDocument.files).forEach(([id, file]) => {
+            if (file.text !== null) {
+                // Skip directories
+                vizFiles[id] = {
+                    name: path.relative(process.cwd(), path.join(fullPath, file.name)),
+                    text: file.text,
+                };
+            }
+        });
+        const fileCount = Object.keys(vizFiles).length;
+        if (fileCount === 0) {
+            console.error("No files found to process");
+            process.exit(1);
+        }
+        console.log(`Found ${fileCount} files to process`);
+        // Create LLM function
+        const llmFunction = (0, llm_1.createOpenRouterLlmFunction)(options.model, apiKey);
+        // Perform the edit
+        console.log("\nRequesting changes from AI...");
+        const result = await (0, index_1.performAiEdit)({
+            prompt: options.prompt,
+            files: vizFiles,
+            llmFunction,
+            apiKey,
+        });
+        // Show changes
+        console.log("\nProposed changes:");
+        for (const [id, file] of Object.entries(result.changedFiles)) {
+            const original = vizFiles[id];
+            if (!original) {
+                console.log(`\nNew file: ${file.name}`);
+                console.log(file.text);
+            }
+            else if (original.text !== file.text) {
+                console.log(`\nModified: ${file.name}`);
+                console.log(file.text);
+            }
+        }
+        // Write changes if not dry run
+        if (!options.dryRun) {
+            console.log("\nWriting changes...");
+            for (const [_, file] of Object.entries(result.changedFiles)) {
+                const fullPath = path.resolve(file.name);
+                await fs.mkdir(path.dirname(fullPath), { recursive: true });
+                await fs.writeFile(fullPath, file.text);
+                console.log(`Updated ${fullPath}`);
+            }
+        }
+        // Show metadata
+        console.log("\nMetadata:");
+        console.log(`Model: ${options.model}`);
+        console.log(`Provider: ${result.provider}`);
+        console.log(`Cost: ${result.upstreamCostCents / 100} USD`);
+        console.log(`Input tokens: ${result.inputTokens}`);
+        console.log(`Output tokens: ${result.outputTokens}`);
+    }
+    catch (error) {
+        console.error("Error:", error);
+        process.exit(1);
+    }
+});
+program.parse();

package/dist/computeInitialDocument.d.ts

@@ -0,0 +1,13 @@
+interface InitialDocument {
+    files: {
+        [key: string]: {
+            text: string | null;
+            name: string;
+        };
+    };
+}
+export declare const isDirectory: (path: string) => boolean;
+export declare const computeInitialDocument: ({ fullPath }: {
+    fullPath: string;
+}) => InitialDocument;
+export {};

package/dist/computeInitialDocument.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeInitialDocument = exports.isDirectory = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ignore_1 = __importDefault(require("ignore"));
+// Configuration constants
+const ignoreFilePattern = '**/{.ignore,.gitignore}';
+const baseIgnore = [
+    '.git',
+    'node_modules',
+    'dist',
+    '*.log',
+    '.DS_Store',
+    'coverage',
+    '.env',
+    '.env.*',
+];
+const debugIgnore = false;
+const debugDirectories = false;
+const enableDirectories = true;
+/**
+ * @param {string} fullPath - absolute path of the workspace root
+ * @param {string} currentDirectoryPath - path where the ignore file is found, relative to fullPath
+ * @param {string} fileName - name of the ignore file
+ * @returns {string[]} parsed lines
+ */
+const parseIgnoreFile = (fullPath, currentDirectory, fileName) => {
+    const filePath = path_1.default.join(fullPath, currentDirectory, fileName);
+    const content = fs_1.default.readFileSync(filePath, 'utf8');
+    const globs = content
+        .split(/[\n\r]+/)
+        .filter(
+    // remove blank line and comments
+    (line) => line.length > 0 && !line.startsWith('#'))
+        .map((line) => {
+        const { bang, slash, glob } = line.match(/^(?<bang>!?)(?<slash>\/?)(?<glob>.*)$/).groups;
+        const hasSlash = Boolean(slash) || /\/.*\S/.test(glob);
+        const relativeGlob = path_1.default.posix.join(currentDirectory.replace(
+        // escape characters with special meaning in glob expressions
+        /[*?!# \[\]\\]/g, (char) => '\\' + char), 
+        // a pattern that doesn't include a slash (not counting a trailing one) matches files in any descendant directory of the current one
+        hasSlash ? '' : '**', glob);
+        // preserve leading `!` and `/` characters
+        return bang + slash + relativeGlob;
+    });
+    if (debugIgnore) {
+        console.debug('at', currentDirectory, 'parsing', fileName, 'obtained globs', globs);
+    }
+    return globs;
+};
+const isDirectory = (path) => path.endsWith('/');
+exports.isDirectory = isDirectory;
+// Lists files from the file system,
+// converts them into the internal data structure.
+const computeInitialDocument = ({ fullPath }) => {
+    // Initialize the document using our data structure for representing files.
+    const initialDocument = {
+        files: {},
+    };
+    /**
+     * Stack for recursively traversing directories.
+     * @type {string[]}
+     */
+    let files = [];
+    const ignoreFileMatcher = (0, ignore_1.default)().add(ignoreFilePattern);
+    const isIgnoreFile = (fileName) => ignoreFileMatcher.ignores(fileName);
+    const unsearchedDirectories = [
+        {
+            currentDirectory: '.',
+            ignore: (0, ignore_1.default)().add(baseIgnore),
+        },
+    ];
+    while (unsearchedDirectories.length !== 0) {
+        const { currentDirectory, ignore: parentIgnore } = unsearchedDirectories.pop();
+        const currentDirectoryPath = path_1.default.join(fullPath, currentDirectory);
+        const dirEntries = fs_1.default
+            .readdirSync(currentDirectoryPath, {
+            withFileTypes: true,
+        })
+            .filter((dirent) => enableDirectories ? true : dirent.isFile());
+        // find .ignore or .gitignore files in the current directory
+        const ignoreFiles = dirEntries
+            .filter((dirent) => dirent.isFile() && isIgnoreFile(dirent.name))
+            .map((file) => file.name);
+        let ignore = parentIgnore;
+        if (ignoreFiles.length > 0) {
+            const globs = ignoreFiles.flatMap((fileName) => parseIgnoreFile(fullPath, currentDirectory, fileName));
+            ignore = (0, ignore_1.default)().add(parentIgnore).add(globs);
+        }
+        const newFiles = dirEntries
+            .filter((dirent) => {
+            const relativePath = path_1.default.posix.join(currentDirectory, dirent.name) +
+                (dirent.isDirectory() ? '/' : '');
+            const keep = !ignore.ignores(relativePath);
+            if (debugIgnore && !keep) {
+                console.debug('at', currentDirectory, 'ignoring', relativePath);
+            }
+            return keep;
+        })
+            // Add a trailing slash for directories
+            .map((dirent) => {
+            const relativePath = path_1.default.posix.join(currentDirectory, dirent.name);
+            if (!dirent.isDirectory()) {
+                return relativePath;
+            }
+            unsearchedDirectories.push({
+                currentDirectory: relativePath,
+                ignore,
+            });
+            return relativePath + '/';
+        });
+        files.push(...newFiles);
+    }
+    files.forEach((file) => {
+        const id = Math.floor(Math.random() * 10000000).toString();
+        initialDocument.files[id] = {
+            text: (0, exports.isDirectory)(file)
+                ? null
+                : fs_1.default.readFileSync(path_1.default.join(fullPath, file), 'utf-8'),
+            name: file,
+        };
+    });
+    if (debugDirectories) {
+        console.log('files:');
+        console.log(files);
+        console.log('initialDocument:');
+        console.log(JSON.stringify(initialDocument, null, 2));
+    }
+    return initialDocument;
+};
+exports.computeInitialDocument = computeInitialDocument;

package/dist/fileUtils.d.ts

@@ -0,0 +1,20 @@
+import { VizFiles, VizFile } from "@vizhub/viz-types";
+/**
+ * If the LLM outputs empty text for a file, we interpret this
+ * as a request to delete the file.
+ */
+export declare function shouldDeleteFile(file?: VizFile): boolean;
+/**
+ * Processes files for the prompt by truncating large files
+ */
+export declare function prepareFilesForPrompt(files: VizFiles): {
+    name: string;
+    text: string;
+}[];
+/**
+ * Merges original files with changes from the LLM
+ */
+export declare function mergeFileChanges(originalFiles: VizFiles, parsedFiles: {
+    name: string;
+    text: string;
+}[]): VizFiles;

package/dist/fileUtils.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldDeleteFile = shouldDeleteFile;
+exports.prepareFilesForPrompt = prepareFilesForPrompt;
+exports.mergeFileChanges = mergeFileChanges;
+const viz_utils_1 = require("@vizhub/viz-utils");
+/**
+ * If the LLM outputs empty text for a file, we interpret this
+ * as a request to delete the file.
+ */
+function shouldDeleteFile(file) {
+    if (!file)
+        return false;
+    return file.text.trim() === "";
+}
+/**
+ * Processes files for the prompt by truncating large files
+ */
+function prepareFilesForPrompt(files) {
+    return Object.values(files).map((file) => ({
+        name: file.name,
+        // Example: truncate large files, etc.
+        text: file.text
+            .split("\n")
+            .slice(0, file.name.endsWith(".csv") || file.name.endsWith(".json") ? 50 : 500)
+            .map((line) => line.slice(0, 200))
+            .join("\n"),
+    }));
+}
+/**
+ * Merges original files with changes from the LLM
+ */
+function mergeFileChanges(originalFiles, parsedFiles) {
+    // Start with existing files
+    let changedFiles = Object.keys(originalFiles).reduce((acc, fileId) => {
+        const original = originalFiles[fileId];
+        const changedFile = parsedFiles.find((f) => f.name === original.name);
+        if (shouldDeleteFile(changedFile)) {
+            // Exclude from new set
+            return acc;
+        }
+        // If changedFile is present, use it; otherwise use original
+        acc[fileId] = {
+            ...original,
+            text: changedFile ? changedFile.text : original.text,
+        };
+        return acc;
+    }, {});
+    // Handle newly-created files
+    parsedFiles.forEach((changedFile) => {
+        const existingFile = Object.values(changedFiles).find((file) => file.name === changedFile.name);
+        // If no existing file and not empty => it's a new file
+        if (!existingFile && !shouldDeleteFile(changedFile)) {
+            const newFileId = (0, viz_utils_1.generateVizFileId)();
+            changedFiles[newFileId] = {
+                name: changedFile.name,
+                text: changedFile.text,
+            };
+        }
+    });
+    return changedFiles;
+}

package/dist/index.d.ts

@@ -1,25 +1,9 @@
-import { VizFiles } from "@vizhub/viz-types";
-export interface PerformAiEditParams {
-    prompt: string;
-    modelName: string;
-    files: VizFiles;
-    apiKey: string;
-    baseURL: string | undefined;
-}
-export interface PerformAiEditResult {
-    changedFiles: VizFiles;
-    openRouterGenerationId: string;
-    upstreamCostCents: number;
-    provider: string;
-    inputTokens: number;
-    outputTokens: number;
-    promptTemplateVersion: number;
-}
+import { PerformAiEditParams, PerformAiEditResult } from "./types";
 /**
  * Core AI logic for:
  * - Building the prompt (including context)
- * - Calling the LLM (ChatOpenAI)
+ * - Calling the provided LLM function
  * - Parsing and merging file changes
  * - Retrieving cost metadata
  */
-export declare function performAiEdit({ prompt, modelName, files, apiKey, baseURL, }: PerformAiEditParams): Promise<PerformAiEditResult>;
+export declare function performAiEdit({ prompt, files, llmFunction, apiKey, }: PerformAiEditParams): Promise<PerformAiEditResult>;