@compilr-dev/agents-coding 0.0.1

package/dist/tools/project/detect.js

@@ -0,0 +1,341 @@
+/**
+ * Project Detection Tool
+ * Detects project type, package manager, and available tools
+ */
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
+/**
+ * Project detection rules - ordered by priority
+ */
+const PROJECT_RULES = [
+    // Node.js
+    { type: 'node', files: ['package.json'], priority: 10 },
+    // Python
+    { type: 'python', files: ['pyproject.toml'], packageManager: 'poetry', priority: 10 },
+    { type: 'python', files: ['setup.py'], packageManager: 'pip', priority: 8 },
+    { type: 'python', files: ['requirements.txt'], packageManager: 'pip', priority: 7 },
+    { type: 'python', files: ['Pipfile'], packageManager: 'pip', priority: 9 },
+    // Rust
+    { type: 'rust', files: ['Cargo.toml'], packageManager: 'cargo', priority: 10 },
+    // Go
+    { type: 'go', files: ['go.mod'], packageManager: 'go', priority: 10 },
+    // Java
+    { type: 'java', files: ['pom.xml'], packageManager: 'maven', priority: 10 },
+    { type: 'java', files: ['build.gradle'], packageManager: 'gradle', priority: 10 },
+    { type: 'java', files: ['build.gradle.kts'], packageManager: 'gradle', priority: 10 },
+    // Ruby
+    { type: 'ruby', files: ['Gemfile'], packageManager: 'bundler', priority: 10 },
+    // PHP
+    { type: 'php', files: ['composer.json'], packageManager: 'composer', priority: 10 },
+    // .NET
+    { type: 'dotnet', files: ['*.csproj'], packageManager: 'dotnet', priority: 10 },
+    { type: 'dotnet', files: ['*.sln'], packageManager: 'dotnet', priority: 9 },
+    { type: 'dotnet', files: ['*.fsproj'], packageManager: 'dotnet', priority: 10 },
+];
+/**
+ * Test framework detection rules
+ */
+const TEST_RULES = [
+    // Node.js
+    { files: ['vitest.config.ts', 'vitest.config.js'], dependencies: ['vitest'], name: 'vitest' },
+    { files: ['jest.config.ts', 'jest.config.js'], dependencies: ['jest'], name: 'jest' },
+    { files: ['.mocharc.json', '.mocharc.js'], dependencies: ['mocha'], name: 'mocha' },
+    { files: ['ava.config.js'], dependencies: ['ava'], name: 'ava' },
+    { files: ['playwright.config.ts'], dependencies: ['@playwright/test'], name: 'playwright' },
+    { files: ['cypress.config.ts'], dependencies: ['cypress'], name: 'cypress' },
+    // Python
+    { files: ['pytest.ini', 'pyproject.toml'], name: 'pytest' },
+    { files: ['setup.cfg'], name: 'unittest' },
+    // Rust
+    { files: ['Cargo.toml'], name: 'cargo test' },
+    // Go
+    { files: ['*_test.go'], name: 'go test' },
+];
+/**
+ * Linter detection rules
+ */
+const LINTER_RULES = [
+    // Node.js
+    {
+        files: ['eslint.config.js', 'eslint.config.mjs', '.eslintrc.js', '.eslintrc.json'],
+        dependencies: ['eslint'],
+        name: 'eslint',
+    },
+    { files: ['biome.json'], dependencies: ['@biomejs/biome'], name: 'biome' },
+    { files: ['tslint.json'], dependencies: ['tslint'], name: 'tslint' },
+    // Python
+    { files: ['ruff.toml', 'pyproject.toml'], name: 'ruff' },
+    { files: ['.pylintrc', 'pyproject.toml'], name: 'pylint' },
+    { files: ['.flake8', 'setup.cfg'], name: 'flake8' },
+    // Rust
+    { files: ['Cargo.toml'], name: 'clippy' },
+    // Go
+    { files: ['.golangci.yml', '.golangci.yaml'], name: 'golangci-lint' },
+];
+/**
+ * Formatter detection rules
+ */
+const FORMATTER_RULES = [
+    // Node.js
+    {
+        files: ['.prettierrc', '.prettierrc.js', '.prettierrc.json'],
+        dependencies: ['prettier'],
+        name: 'prettier',
+    },
+    { files: ['biome.json'], dependencies: ['@biomejs/biome'], name: 'biome' },
+    // Python
+    { files: ['pyproject.toml'], name: 'black' },
+    { files: ['ruff.toml', 'pyproject.toml'], name: 'ruff format' },
+    // Rust
+    { files: ['rustfmt.toml', '.rustfmt.toml'], name: 'rustfmt' },
+    // Go
+    { files: ['go.mod'], name: 'gofmt' },
+];
+/**
+ * Build tool detection rules
+ */
+const BUILD_RULES = [
+    // Node.js
+    { files: ['vite.config.ts', 'vite.config.js'], dependencies: ['vite'], name: 'vite' },
+    { files: ['webpack.config.js'], dependencies: ['webpack'], name: 'webpack' },
+    { files: ['rollup.config.js'], dependencies: ['rollup'], name: 'rollup' },
+    { files: ['esbuild.config.js'], dependencies: ['esbuild'], name: 'esbuild' },
+    { files: ['tsconfig.json'], dependencies: ['typescript'], scripts: ['build'], name: 'tsc' },
+    { files: ['turbo.json'], dependencies: ['turbo'], name: 'turborepo' },
+    { files: ['nx.json'], dependencies: ['nx'], name: 'nx' },
+    // Rust
+    { files: ['Cargo.toml'], name: 'cargo build' },
+    // Go
+    { files: ['go.mod'], name: 'go build' },
+];
+/**
+ * Detect project tool
+ */
+export const detectProjectTool = defineTool({
+    name: 'detect_project',
+    description: 'Detect the type of project in a directory. ' +
+        'Returns project type (node, python, rust, go, java, etc.), ' +
+        'package manager, test framework, linter, formatter, and build tool.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'Directory to analyze (default: current directory)',
+            },
+        },
+        required: [],
+    },
+    execute: executeDetectProject,
+});
+/**
+ * Execute project detection
+ */
+async function executeDetectProject(input) {
+    const targetPath = input.path ?? process.cwd();
+    // Check if directory exists
+    try {
+        const stats = await stat(targetPath);
+        if (!stats.isDirectory()) {
+            return createErrorResult(`Not a directory: ${targetPath}`);
+        }
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === 'ENOENT') {
+            return createErrorResult(`Directory not found: ${targetPath}`);
+        }
+        return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+    try {
+        // List directory contents
+        const entries = await readdir(targetPath);
+        const configFiles = [];
+        // Detect project types
+        const detectedTypes = new Map();
+        for (const rule of PROJECT_RULES) {
+            for (const pattern of rule.files) {
+                if (pattern.includes('*')) {
+                    // Glob pattern
+                    const regex = new RegExp('^' + pattern.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$');
+                    const matches = entries.filter((e) => regex.test(e));
+                    if (matches.length > 0) {
+                        configFiles.push(...matches);
+                        const existing = detectedTypes.get(rule.type);
+                        if (!existing || existing.priority < rule.priority) {
+                            detectedTypes.set(rule.type, {
+                                packageManager: rule.packageManager,
+                                priority: rule.priority,
+                            });
+                        }
+                    }
+                }
+                else {
+                    // Exact match
+                    if (entries.includes(pattern)) {
+                        configFiles.push(pattern);
+                        const existing = detectedTypes.get(rule.type);
+                        if (!existing || existing.priority < rule.priority) {
+                            detectedTypes.set(rule.type, {
+                                packageManager: rule.packageManager,
+                                priority: rule.priority,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        // Load package.json for additional detection
+        let packageJson = null;
+        if (entries.includes('package.json')) {
+            try {
+                const content = await readFile(join(targetPath, 'package.json'), 'utf-8');
+                packageJson = JSON.parse(content);
+            }
+            catch {
+                // Ignore parse errors
+            }
+        }
+        // Detect Node.js package manager from lockfiles
+        let nodePackageManager;
+        if (entries.includes('pnpm-lock.yaml')) {
+            nodePackageManager = 'pnpm';
+        }
+        else if (entries.includes('yarn.lock')) {
+            nodePackageManager = 'yarn';
+        }
+        else if (entries.includes('package-lock.json')) {
+            nodePackageManager = 'npm';
+        }
+        // Update node package manager if detected
+        if (nodePackageManager && detectedTypes.has('node')) {
+            const nodeInfo = detectedTypes.get('node');
+            if (nodeInfo) {
+                detectedTypes.set('node', { ...nodeInfo, packageManager: nodePackageManager });
+            }
+        }
+        // Determine primary type (highest priority)
+        let primaryType = 'unknown';
+        let primaryPackageManager;
+        let highestPriority = -1;
+        for (const [type, info] of detectedTypes) {
+            if (info.priority > highestPriority) {
+                highestPriority = info.priority;
+                primaryType = type;
+                primaryPackageManager = info.packageManager;
+            }
+        }
+        // Detect tools
+        const testFramework = await detectTool(targetPath, entries, TEST_RULES, packageJson);
+        const linter = await detectTool(targetPath, entries, LINTER_RULES, packageJson);
+        const formatter = await detectTool(targetPath, entries, FORMATTER_RULES, packageJson);
+        const buildTool = await detectTool(targetPath, entries, BUILD_RULES, packageJson);
+        const result = {
+            type: primaryType,
+            types: Array.from(detectedTypes.keys()),
+            packageManager: primaryPackageManager,
+            testFramework,
+            linter,
+            formatter,
+            buildTool,
+            configFiles: [...new Set(configFiles)],
+            name: packageJson?.name,
+        };
+        return createSuccessResult(result);
+    }
+    catch (error) {
+        return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * Detect a tool from rules
+ */
+async function detectTool(targetPath, entries, rules, packageJson) {
+    for (const rule of rules) {
+        // Check files
+        for (const pattern of rule.files) {
+            if (pattern.includes('*')) {
+                const regex = new RegExp('^' + pattern.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$');
+                if (entries.some((e) => regex.test(e))) {
+                    // Additional check for pyproject.toml - verify it contains the tool
+                    if (pattern === 'pyproject.toml' && entries.includes('pyproject.toml')) {
+                        try {
+                            const content = await readFile(join(targetPath, 'pyproject.toml'), 'utf-8');
+                            if ((rule.name === 'pytest' && content.includes('[tool.pytest')) ||
+                                (rule.name === 'black' && content.includes('[tool.black')) ||
+                                (rule.name === 'ruff' && content.includes('[tool.ruff')) ||
+                                (rule.name === 'ruff format' && content.includes('[tool.ruff'))) {
+                                return rule.name;
+                            }
+                        }
+                        catch {
+                            // Ignore read errors
+                        }
+                    }
+                    else {
+                        return rule.name;
+                    }
+                }
+            }
+            else if (entries.includes(pattern)) {
+                return rule.name;
+            }
+        }
+        // Check package.json dependencies
+        if (packageJson && rule.dependencies) {
+            const allDeps = {
+                ...packageJson.dependencies,
+                ...packageJson.devDependencies,
+            };
+            for (const dep of rule.dependencies) {
+                if (allDeps[dep]) {
+                    return rule.name;
+                }
+            }
+        }
+        // Check package.json scripts
+        if (packageJson?.scripts && rule.scripts) {
+            for (const script of rule.scripts) {
+                if (packageJson.scripts[script]) {
+                    return rule.name;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Check if error is a Node.js error with code
+ */
+function isNodeError(error) {
+    return error instanceof Error && 'code' in error;
+}
+/**
+ * Factory function to create detect project tool with custom options
+ */
+export function createDetectProjectTool(options) {
+    return defineTool({
+        name: 'detect_project',
+        description: 'Detect the type of project in a directory. ' +
+            'Returns project type (node, python, rust, go, java, etc.), ' +
+            'package manager, test framework, linter, formatter, and build tool.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Directory to analyze (default: current directory)',
+                },
+            },
+            required: [],
+        },
+        execute: async (input) => {
+            let targetPath = input.path ?? '.';
+            // Resolve relative paths
+            if (options?.baseDir && !targetPath.startsWith('/')) {
+                targetPath = join(options.baseDir, targetPath);
+            }
+            return executeDetectProject({ path: targetPath });
+        },
+    });
+}

package/dist/tools/project/find-root.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Find Project Root Tool
+ * Finds the root directory of a project by looking for marker files
+ */
+import type { Tool } from '@compilr-dev/agents';
+import type { FindProjectRootInput } from './types.js';
+/**
+ * Find project root tool
+ */
+export declare const findProjectRootTool: Tool<FindProjectRootInput>;
+/**
+ * Factory function to create find project root tool with custom options
+ */
+export declare function createFindProjectRootTool(options?: {
+    /** Base directory for relative paths */
+    baseDir?: string;
+    /** Default markers to use */
+    defaultMarkers?: string[];
+    /** Maximum depth to search */
+    maxDepth?: number;
+}): Tool<FindProjectRootInput>;

package/dist/tools/project/find-root.js

@@ -0,0 +1,239 @@
+/**
+ * Find Project Root Tool
+ * Finds the root directory of a project by looking for marker files
+ */
+import { access, stat } from 'node:fs/promises';
+import { join, dirname, resolve, sep } from 'node:path';
+import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
+/**
+ * Default marker files to look for when finding project root
+ */
+const DEFAULT_MARKERS = [
+    // Version control
+    '.git',
+    '.hg',
+    '.svn',
+    // Node.js
+    'package.json',
+    // Python
+    'pyproject.toml',
+    'setup.py',
+    'setup.cfg',
+    // Rust
+    'Cargo.toml',
+    // Go
+    'go.mod',
+    // Java
+    'pom.xml',
+    'build.gradle',
+    'build.gradle.kts',
+    // Ruby
+    'Gemfile',
+    // PHP
+    'composer.json',
+    // .NET
+    '*.sln',
+    '*.csproj',
+    // Generic
+    '.project-root', // Explicit marker file
+];
+/**
+ * Find project root tool
+ */
+export const findProjectRootTool = defineTool({
+    name: 'find_project_root',
+    description: 'Find the root directory of a project by looking for marker files. ' +
+        'Searches upward from the starting directory until a marker is found. ' +
+        'Common markers: .git, package.json, Cargo.toml, go.mod, etc.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'Starting directory (default: current directory)',
+            },
+            markers: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Marker files to look for (default: common project files)',
+            },
+        },
+        required: [],
+    },
+    execute: executeFindProjectRoot,
+});
+/**
+ * Execute find project root
+ */
+async function executeFindProjectRoot(input) {
+    const startPath = resolve(input.path ?? process.cwd());
+    const markers = input.markers ?? DEFAULT_MARKERS;
+    // Check if start path exists
+    try {
+        const stats = await stat(startPath);
+        if (!stats.isDirectory()) {
+            return createErrorResult(`Not a directory: ${startPath}`);
+        }
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === 'ENOENT') {
+            return createErrorResult(`Directory not found: ${startPath}`);
+        }
+        return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+    try {
+        let currentPath = startPath;
+        let depth = 0;
+        const root = getRootPath();
+        while (currentPath.length >= root.length) {
+            // Check each marker
+            for (const marker of markers) {
+                if (marker.includes('*')) {
+                    // Glob pattern - check if any matching file exists
+                    const found = await checkGlobMarker(currentPath, marker);
+                    if (found) {
+                        const result = {
+                            root: currentPath,
+                            foundMarker: found,
+                            depth,
+                        };
+                        return createSuccessResult(result);
+                    }
+                }
+                else {
+                    // Exact match
+                    const markerPath = join(currentPath, marker);
+                    if (await fileExists(markerPath)) {
+                        const result = {
+                            root: currentPath,
+                            foundMarker: marker,
+                            depth,
+                        };
+                        return createSuccessResult(result);
+                    }
+                }
+            }
+            // Move up one directory
+            const parentPath = dirname(currentPath);
+            if (parentPath === currentPath) {
+                // Reached filesystem root
+                break;
+            }
+            currentPath = parentPath;
+            depth++;
+        }
+        return createErrorResult(`No project root found. Searched from ${startPath} to filesystem root.`);
+    }
+    catch (error) {
+        return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * Check if a file exists
+ */
+async function fileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check for glob marker pattern (e.g., *.sln)
+ */
+async function checkGlobMarker(directory, pattern) {
+    const { readdir } = await import('node:fs/promises');
+    try {
+        const entries = await readdir(directory);
+        const regex = new RegExp('^' + pattern.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$');
+        for (const entry of entries) {
+            if (regex.test(entry)) {
+                return entry;
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get the root path for the current platform
+ */
+function getRootPath() {
+    // On Windows, root could be C:\, D:\, etc.
+    // On Unix, root is /
+    if (process.platform === 'win32') {
+        return process.cwd().split(sep)[0] + sep;
+    }
+    return '/';
+}
+/**
+ * Check if error is a Node.js error with code
+ */
+function isNodeError(error) {
+    return error instanceof Error && 'code' in error;
+}
+/**
+ * Factory function to create find project root tool with custom options
+ */
+export function createFindProjectRootTool(options) {
+    return defineTool({
+        name: 'find_project_root',
+        description: 'Find the root directory of a project by looking for marker files. ' +
+            'Searches upward from the starting directory until a marker is found. ' +
+            'Common markers: .git, package.json, Cargo.toml, go.mod, etc.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Starting directory (default: current directory)',
+                },
+                markers: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Marker files to look for (default: common project files)',
+                },
+            },
+            required: [],
+        },
+        execute: async (input) => {
+            let startPath = input.path ?? '.';
+            const markers = input.markers ?? options?.defaultMarkers ?? DEFAULT_MARKERS;
+            // Resolve relative paths
+            if (options?.baseDir && !startPath.startsWith('/')) {
+                startPath = join(options.baseDir, startPath);
+            }
+            // If maxDepth is set, limit the search
+            if (options?.maxDepth !== undefined) {
+                const absoluteStart = resolve(startPath);
+                let currentPath = absoluteStart;
+                let depth = 0;
+                while (depth <= options.maxDepth) {
+                    // Check markers at current depth
+                    for (const marker of markers) {
+                        const markerPath = join(currentPath, marker);
+                        if (await fileExists(markerPath)) {
+                            const result = {
+                                root: currentPath,
+                                foundMarker: marker,
+                                depth,
+                            };
+                            return createSuccessResult(result);
+                        }
+                    }
+                    const parentPath = dirname(currentPath);
+                    if (parentPath === currentPath)
+                        break;
+                    currentPath = parentPath;
+                    depth++;
+                }
+                return createErrorResult(`No project root found within ${String(options.maxDepth)} directories of ${startPath}`);
+            }
+            return executeFindProjectRoot({ path: startPath, markers });
+        },
+    });
+}

package/dist/tools/project/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Project detection tools
+ */
+export { detectProjectTool, createDetectProjectTool } from './detect.js';
+export { findProjectRootTool, createFindProjectRootTool } from './find-root.js';
+export type { DetectProjectInput, DetectProjectResult, ProjectType, PackageManager, FindProjectRootInput, FindProjectRootResult, } from './types.js';

package/dist/tools/project/index.js

@@ -0,0 +1,5 @@
+/**
+ * Project detection tools
+ */
+export { detectProjectTool, createDetectProjectTool } from './detect.js';
+export { findProjectRootTool, createFindProjectRootTool } from './find-root.js';