codeep 1.0.0

package/dist/utils/verify.js

@@ -0,0 +1,464 @@
+/**
+ * Self-verification module for agent
+ * Runs build/test and analyzes errors for auto-fixing
+ */
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { executeCommand } from './shell';
+const DEFAULT_OPTIONS = {
+    runBuild: true,
+    runTest: true,
+    runLint: false,
+    runTypecheck: true,
+    timeout: 120000, // 2 minutes
+};
+/**
+ * Detect project type and available scripts
+ */
+export function detectProjectScripts(projectRoot) {
+    const result = {
+        packageManager: 'npm',
+    };
+    // Detect package manager
+    if (existsSync(join(projectRoot, 'bun.lockb'))) {
+        result.packageManager = 'bun';
+    }
+    else if (existsSync(join(projectRoot, 'pnpm-lock.yaml'))) {
+        result.packageManager = 'pnpm';
+    }
+    else if (existsSync(join(projectRoot, 'yarn.lock'))) {
+        result.packageManager = 'yarn';
+    }
+    // Check package.json for scripts
+    const packageJsonPath = join(projectRoot, 'package.json');
+    if (existsSync(packageJsonPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+            const scripts = pkg.scripts || {};
+            // Build command
+            if (scripts.build) {
+                result.build = 'build';
+            }
+            else if (scripts.compile) {
+                result.build = 'compile';
+            }
+            // Test command
+            if (scripts.test) {
+                result.test = 'test';
+            }
+            else if (scripts.spec) {
+                result.test = 'spec';
+            }
+            // Lint command
+            if (scripts.lint) {
+                result.lint = 'lint';
+            }
+            else if (scripts.eslint) {
+                result.lint = 'eslint';
+            }
+            // Typecheck command
+            if (scripts.typecheck) {
+                result.typecheck = 'typecheck';
+            }
+            else if (scripts['type-check']) {
+                result.typecheck = 'type-check';
+            }
+            else if (scripts.tsc) {
+                result.typecheck = 'tsc';
+            }
+            else if (existsSync(join(projectRoot, 'tsconfig.json'))) {
+                // TypeScript project without explicit typecheck script
+                result.typecheck = '__tsc_direct__';
+            }
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    // Python project
+    const requirementsPath = join(projectRoot, 'requirements.txt');
+    const pyprojectPath = join(projectRoot, 'pyproject.toml');
+    if (existsSync(requirementsPath) || existsSync(pyprojectPath)) {
+        if (existsSync(join(projectRoot, 'pytest.ini')) || existsSync(join(projectRoot, 'tests'))) {
+            result.test = '__pytest__';
+        }
+    }
+    // Go project
+    if (existsSync(join(projectRoot, 'go.mod'))) {
+        result.build = '__go_build__';
+        result.test = '__go_test__';
+    }
+    // Rust project
+    if (existsSync(join(projectRoot, 'Cargo.toml'))) {
+        result.build = '__cargo_build__';
+        result.test = '__cargo_test__';
+    }
+    // PHP project (Composer)
+    if (existsSync(join(projectRoot, 'composer.json'))) {
+        try {
+            const composer = JSON.parse(readFileSync(join(projectRoot, 'composer.json'), 'utf-8'));
+            const scripts = composer.scripts || {};
+            if (scripts.test) {
+                result.test = '__composer_test__';
+            }
+            else if (existsSync(join(projectRoot, 'phpunit.xml')) || existsSync(join(projectRoot, 'phpunit.xml.dist'))) {
+                result.test = '__phpunit__';
+            }
+            if (scripts.build) {
+                result.build = '__composer_build__';
+            }
+            // PHP syntax check
+            result.typecheck = '__php_lint__';
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    // Laravel project
+    if (existsSync(join(projectRoot, 'artisan'))) {
+        result.test = '__artisan_test__';
+    }
+    return result;
+}
+/**
+ * Run a verification command
+ */
+function runVerifyCommand(type, command, args, projectRoot, timeout) {
+    const startTime = Date.now();
+    const result = executeCommand(command, args, {
+        cwd: projectRoot,
+        projectRoot,
+        timeout,
+    });
+    const duration = Date.now() - startTime;
+    const output = result.stdout + '\n' + result.stderr;
+    // Parse errors from output
+    const errors = parseErrors(output, type);
+    return {
+        success: result.success,
+        type,
+        command: `${command} ${args.join(' ')}`,
+        output: output.trim(),
+        errors,
+        duration,
+    };
+}
+/**
+ * Parse errors from command output
+ */
+function parseErrors(output, type) {
+    const errors = [];
+    const lines = output.split('\n');
+    for (const line of lines) {
+        // TypeScript/TSC errors: src/file.ts(10,5): error TS2345: ...
+        const tsMatch = line.match(/^(.+?)\((\d+),(\d+)\):\s*(error|warning)\s+(TS\d+):\s*(.+)$/);
+        if (tsMatch) {
+            errors.push({
+                file: tsMatch[1],
+                line: parseInt(tsMatch[2]),
+                column: parseInt(tsMatch[3]),
+                severity: tsMatch[4],
+                code: tsMatch[5],
+                message: tsMatch[6],
+            });
+            continue;
+        }
+        // ESLint/Prettier: /path/to/file.ts:10:5: error ...
+        const eslintMatch = line.match(/^(.+?):(\d+):(\d+):\s*(error|warning)\s+(.+)$/);
+        if (eslintMatch) {
+            errors.push({
+                file: eslintMatch[1],
+                line: parseInt(eslintMatch[2]),
+                column: parseInt(eslintMatch[3]),
+                severity: eslintMatch[4],
+                message: eslintMatch[5],
+            });
+            continue;
+        }
+        // Jest/Vitest: FAIL src/file.test.ts
+        const jestFailMatch = line.match(/^\s*FAIL\s+(.+)$/);
+        if (jestFailMatch) {
+            errors.push({
+                file: jestFailMatch[1],
+                severity: 'error',
+                message: 'Test file failed',
+            });
+            continue;
+        }
+        // Generic error with file:line
+        const genericMatch = line.match(/^(.+?):(\d+):\s*(.+error.+)$/i);
+        if (genericMatch) {
+            errors.push({
+                file: genericMatch[1],
+                line: parseInt(genericMatch[2]),
+                severity: 'error',
+                message: genericMatch[3],
+            });
+            continue;
+        }
+        // Go errors: file.go:10:5: ...
+        const goMatch = line.match(/^(.+\.go):(\d+):(\d+):\s*(.+)$/);
+        if (goMatch) {
+            errors.push({
+                file: goMatch[1],
+                line: parseInt(goMatch[2]),
+                column: parseInt(goMatch[3]),
+                severity: 'error',
+                message: goMatch[4],
+            });
+            continue;
+        }
+        // Rust errors: error[E0001]: ... --> src/main.rs:10:5
+        const rustMatch = line.match(/^\s*-->\s*(.+?):(\d+):(\d+)$/);
+        if (rustMatch) {
+            errors.push({
+                file: rustMatch[1],
+                line: parseInt(rustMatch[2]),
+                column: parseInt(rustMatch[3]),
+                severity: 'error',
+                message: 'Rust compilation error',
+            });
+            continue;
+        }
+        // PHP errors: PHP Parse error: ... in /path/file.php on line 10
+        const phpMatch = line.match(/PHP\s+(Parse error|Fatal error|Warning):\s*(.+?)\s+in\s+(.+?)\s+on line\s+(\d+)/i);
+        if (phpMatch) {
+            errors.push({
+                file: phpMatch[3],
+                line: parseInt(phpMatch[4]),
+                severity: phpMatch[1].toLowerCase().includes('warning') ? 'warning' : 'error',
+                message: phpMatch[2],
+            });
+            continue;
+        }
+        // PHPUnit errors: 1) TestClass::testMethod
+        const phpunitMatch = line.match(/^\d+\)\s+(.+)::(.+)$/);
+        if (phpunitMatch) {
+            errors.push({
+                severity: 'error',
+                message: `Test failed: ${phpunitMatch[1]}::${phpunitMatch[2]}`,
+            });
+            continue;
+        }
+    }
+    return errors;
+}
+/**
+ * Run build verification
+ */
+export function runBuildVerification(projectRoot, timeout = 120000) {
+    const scripts = detectProjectScripts(projectRoot);
+    if (!scripts.build) {
+        return null;
+    }
+    let command;
+    let args;
+    if (scripts.build === '__go_build__') {
+        command = 'go';
+        args = ['build', './...'];
+    }
+    else if (scripts.build === '__cargo_build__') {
+        command = 'cargo';
+        args = ['build'];
+    }
+    else if (scripts.build === '__composer_build__') {
+        command = 'composer';
+        args = ['run', 'build'];
+    }
+    else {
+        command = scripts.packageManager;
+        args = ['run', scripts.build];
+    }
+    return runVerifyCommand('build', command, args, projectRoot, timeout);
+}
+/**
+ * Run test verification
+ */
+export function runTestVerification(projectRoot, timeout = 120000) {
+    const scripts = detectProjectScripts(projectRoot);
+    if (!scripts.test) {
+        return null;
+    }
+    let command;
+    let args;
+    if (scripts.test === '__pytest__') {
+        command = 'pytest';
+        args = ['-v'];
+    }
+    else if (scripts.test === '__go_test__') {
+        command = 'go';
+        args = ['test', './...'];
+    }
+    else if (scripts.test === '__cargo_test__') {
+        command = 'cargo';
+        args = ['test'];
+    }
+    else if (scripts.test === '__phpunit__') {
+        command = './vendor/bin/phpunit';
+        args = [];
+    }
+    else if (scripts.test === '__composer_test__') {
+        command = 'composer';
+        args = ['run', 'test'];
+    }
+    else if (scripts.test === '__artisan_test__') {
+        command = 'php';
+        args = ['artisan', 'test'];
+    }
+    else {
+        command = scripts.packageManager;
+        args = ['run', scripts.test];
+    }
+    return runVerifyCommand('test', command, args, projectRoot, timeout);
+}
+/**
+ * Run TypeScript type checking
+ */
+export function runTypecheckVerification(projectRoot, timeout = 60000) {
+    const scripts = detectProjectScripts(projectRoot);
+    if (!scripts.typecheck) {
+        return null;
+    }
+    let command;
+    let args;
+    if (scripts.typecheck === '__tsc_direct__') {
+        command = 'npx';
+        args = ['tsc', '--noEmit'];
+    }
+    else if (scripts.typecheck === '__php_lint__') {
+        // PHP syntax check on all PHP files
+        command = 'find';
+        args = ['.', '-name', '*.php', '-not', '-path', './vendor/*', '-exec', 'php', '-l', '{}', ';'];
+    }
+    else {
+        command = scripts.packageManager;
+        args = ['run', scripts.typecheck];
+    }
+    return runVerifyCommand('typecheck', command, args, projectRoot, timeout);
+}
+/**
+ * Run lint verification
+ */
+export function runLintVerification(projectRoot, timeout = 60000) {
+    const scripts = detectProjectScripts(projectRoot);
+    if (!scripts.lint) {
+        return null;
+    }
+    const command = scripts.packageManager;
+    const args = ['run', scripts.lint];
+    return runVerifyCommand('lint', command, args, projectRoot, timeout);
+}
+/**
+ * Run all verifications
+ */
+export function runAllVerifications(projectRoot, options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const results = [];
+    // Run typecheck first (fastest feedback)
+    if (opts.runTypecheck) {
+        const result = runTypecheckVerification(projectRoot, opts.timeout);
+        if (result)
+            results.push(result);
+    }
+    // Run build
+    if (opts.runBuild) {
+        const result = runBuildVerification(projectRoot, opts.timeout);
+        if (result)
+            results.push(result);
+    }
+    // Run lint
+    if (opts.runLint) {
+        const result = runLintVerification(projectRoot, opts.timeout);
+        if (result)
+            results.push(result);
+    }
+    // Run tests last (slowest)
+    if (opts.runTest) {
+        const result = runTestVerification(projectRoot, opts.timeout);
+        if (result)
+            results.push(result);
+    }
+    return results;
+}
+/**
+ * Format verification results for display
+ */
+export function formatVerifyResults(results) {
+    const lines = [];
+    for (const result of results) {
+        const status = result.success ? '✓' : '✗';
+        const duration = `${(result.duration / 1000).toFixed(1)}s`;
+        lines.push(`${status} ${result.type}: ${result.command} (${duration})`);
+        if (!result.success && result.errors.length > 0) {
+            const errorCount = result.errors.filter(e => e.severity === 'error').length;
+            const warnCount = result.errors.filter(e => e.severity === 'warning').length;
+            lines.push(`  ${errorCount} error(s), ${warnCount} warning(s)`);
+            // Show first few errors
+            for (const error of result.errors.slice(0, 5)) {
+                const loc = error.file ? `${error.file}:${error.line || '?'}` : '';
+                lines.push(`  - ${loc}: ${error.message}`);
+            }
+            if (result.errors.length > 5) {
+                lines.push(`  ... and ${result.errors.length - 5} more`);
+            }
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * Format errors for agent to fix
+ */
+export function formatErrorsForAgent(results) {
+    const failedResults = results.filter(r => !r.success);
+    if (failedResults.length === 0) {
+        return '';
+    }
+    const lines = ['## Verification Errors - Please Fix:', ''];
+    for (const result of failedResults) {
+        lines.push(`### ${result.type.toUpperCase()} Failed`);
+        lines.push(`Command: ${result.command}`);
+        lines.push('');
+        if (result.errors.length > 0) {
+            lines.push('Errors:');
+            for (const error of result.errors) {
+                const loc = error.file
+                    ? `${error.file}${error.line ? `:${error.line}` : ''}${error.column ? `:${error.column}` : ''}`
+                    : 'unknown';
+                lines.push(`- [${loc}] ${error.message}${error.code ? ` (${error.code})` : ''}`);
+            }
+        }
+        else {
+            // No parsed errors, show raw output
+            lines.push('Output:');
+            lines.push('```');
+            lines.push(result.output.slice(0, 2000));
+            if (result.output.length > 2000) {
+                lines.push('... (truncated)');
+            }
+            lines.push('```');
+        }
+        lines.push('');
+    }
+    lines.push('Please fix these errors and try again.');
+    return lines.join('\n');
+}
+/**
+ * Check if any verification failed
+ */
+export function hasVerificationErrors(results) {
+    return results.some(r => !r.success);
+}
+/**
+ * Get summary of verification
+ */
+export function getVerificationSummary(results) {
+    const passed = results.filter(r => r.success).length;
+    const failed = results.filter(r => !r.success).length;
+    const errors = results.reduce((sum, r) => sum + r.errors.filter(e => e.severity === 'error').length, 0);
+    return {
+        passed,
+        failed,
+        total: results.length,
+        errors,
+    };
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "codeep",
+  "version": "1.0.0",
+  "description": "AI-powered coding assistant built for the terminal. Multiple LLM providers, project-aware context, and a seamless development workflow.",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "codeep": "dist/index.js"
+  },
+  "scripts": {
+    "dev": "node --import tsx src/index.tsx",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "build:binary": "npm run build && pkg dist/index.js --targets node18-macos-arm64,node18-macos-x64,node18-linux-x64 --output bin/codeep",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/VladoIvankovic/Codeep.git"
+  },
+  "keywords": [
+    "ai",
+    "cli",
+    "tui",
+    "glm",
+    "z.ai",
+    "coding",
+    "assistant"
+  ],
+  "author": "Vlado Ivankovic",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/VladoIvankovic/Codeep/issues"
+  },
+  "homepage": "https://codeep.dev",
+  "dependencies": {
+    "clipboardy": "^4.0.0",
+    "conf": "^12.0.0",
+    "ink": "^4.4.1",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^5.0.1",
+    "keytar": "^7.9.0",
+    "open": "^10.0.0",
+    "react": "^18.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "@types/react": "^18.2.0",
+    "@vitest/coverage-v8": "^4.0.18",
+    "pkg": "^5.8.1",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.0",
+    "vitest": "^4.0.18"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}