@compilr-dev/agents-coding 0.0.1

package/dist/tools/git/types.d.ts

@@ -0,0 +1,293 @@
+/**
+ * Types for git tools
+ */
+/**
+ * Git file status indicator
+ */
+export type GitFileStatusType = 'added' | 'modified' | 'deleted' | 'renamed' | 'copied' | 'untracked';
+/**
+ * Git file status entry
+ */
+export interface GitFileStatus {
+    /** File path */
+    path: string;
+    /** Status type */
+    status: GitFileStatusType;
+    /** Original path (for renames) */
+    oldPath?: string;
+}
+/**
+ * Input for gitStatus tool
+ */
+export interface GitStatusInput {
+    /** Working directory path (default: current directory) */
+    path?: string;
+    /** Include untracked files (default: true) */
+    includeUntracked?: boolean;
+    /** Short format output (default: false) */
+    short?: boolean;
+}
+/**
+ * Result of git status
+ */
+export interface GitStatusResult {
+    /** Current branch name */
+    branch: string;
+    /** Tracking branch info */
+    tracking?: {
+        remote: string;
+        ahead: number;
+        behind: number;
+    };
+    /** Staged files */
+    staged: GitFileStatus[];
+    /** Unstaged modified files */
+    modified: GitFileStatus[];
+    /** Untracked files */
+    untracked: string[];
+    /** Is working tree clean? */
+    isClean: boolean;
+    /** Short status output (if requested) */
+    shortStatus?: string;
+}
+/**
+ * Input for gitDiff tool
+ */
+export interface GitDiffInput {
+    /** Working directory path */
+    path?: string;
+    /** Compare staged changes (default: false, shows unstaged) */
+    staged?: boolean;
+    /** Specific file to diff */
+    file?: string;
+    /** Compare with specific commit/branch */
+    ref?: string;
+    /** Compare two refs (use with refB) */
+    refA?: string;
+    /** Second ref to compare */
+    refB?: string;
+    /** Context lines (default: 3) */
+    context?: number;
+    /** Stat only, no content (default: false) */
+    statOnly?: boolean;
+    /** Name only, just list changed files */
+    nameOnly?: boolean;
+}
+/**
+ * File change stats in diff
+ */
+export interface DiffFileStats {
+    path: string;
+    additions: number;
+    deletions: number;
+}
+/**
+ * Result of git diff
+ */
+export interface GitDiffResult {
+    /** Diff output (empty if statOnly) */
+    diff: string;
+    /** Files changed */
+    files: DiffFileStats[];
+    /** Summary stats */
+    stats: {
+        filesChanged: number;
+        insertions: number;
+        deletions: number;
+    };
+}
+/**
+ * Input for gitLog tool
+ */
+export interface GitLogInput {
+    /** Working directory path */
+    path?: string;
+    /** Number of commits to return (default: 10) */
+    limit?: number;
+    /** Filter by file path */
+    file?: string;
+    /** Filter by author */
+    author?: string;
+    /** Since date (ISO format or relative like "2 weeks ago") */
+    since?: string;
+    /** Until date (ISO format or relative) */
+    until?: string;
+    /** One-line format (hash + message only) */
+    oneline?: boolean;
+    /** Include diff stat */
+    stat?: boolean;
+    /** Filter by grep pattern in commit message */
+    grep?: string;
+    /** Branch or ref to show log for */
+    ref?: string;
+}
+/**
+ * Git commit entry
+ */
+export interface GitCommit {
+    /** Full commit hash */
+    hash: string;
+    /** Short commit hash (7 chars) */
+    shortHash: string;
+    /** Author name */
+    author: string;
+    /** Author email */
+    email: string;
+    /** Commit date (ISO format) */
+    date: string;
+    /** Commit subject (first line) */
+    message: string;
+    /** Commit body (remaining lines) */
+    body?: string;
+    /** Stat info if requested */
+    stat?: string;
+}
+/**
+ * Result of git log
+ */
+export interface GitLogResult {
+    /** List of commits */
+    commits: GitCommit[];
+    /** Total commits found (may be more than returned if limit applied) */
+    totalCount?: number;
+}
+/**
+ * Input for gitCommit tool
+ */
+export interface GitCommitInput {
+    /** Working directory path */
+    path?: string;
+    /** Commit message (required) */
+    message: string;
+    /** Files to add before commit (specific files only) */
+    files?: string[];
+    /** Add all modified/deleted files (git add -u) */
+    addModified?: boolean;
+    /** Add all files including untracked (git add -A) */
+    addAll?: boolean;
+    /** Allow empty commit */
+    allowEmpty?: boolean;
+    /** Amend previous commit (use with caution!) */
+    amend?: boolean;
+    /** Skip pre-commit hooks (use with caution!) */
+    noVerify?: boolean;
+}
+/**
+ * Result of git commit
+ */
+export interface GitCommitResult {
+    /** Commit hash */
+    hash: string;
+    /** Short hash */
+    shortHash: string;
+    /** Branch committed to */
+    branch: string;
+    /** Number of files committed */
+    filesCommitted: number;
+    /** Lines inserted */
+    insertions: number;
+    /** Lines deleted */
+    deletions: number;
+    /** Commit message used */
+    message: string;
+}
+/**
+ * Safety warning from commit tool
+ */
+export interface CommitSafetyWarning {
+    type: 'secrets' | 'large_file' | 'binary';
+    file: string;
+    message: string;
+}
+/**
+ * Branch action types
+ */
+export type GitBranchAction = 'list' | 'create' | 'delete' | 'switch' | 'rename';
+/**
+ * Input for gitBranch tool
+ */
+export interface GitBranchInput {
+    /** Working directory path */
+    path?: string;
+    /** Action to perform */
+    action: GitBranchAction;
+    /** Branch name (for create/delete/switch/rename) */
+    name?: string;
+    /** New name (for rename action) */
+    newName?: string;
+    /** Include remote branches in list */
+    remotes?: boolean;
+    /** Force delete even if not merged */
+    force?: boolean;
+    /** Start point for new branch (commit/branch) */
+    startPoint?: string;
+}
+/**
+ * Branch info entry
+ */
+export interface GitBranchInfo {
+    /** Branch name */
+    name: string;
+    /** Is this a remote branch? */
+    isRemote: boolean;
+    /** Is this the current branch? */
+    isCurrent: boolean;
+    /** Tracking remote branch */
+    tracking?: string;
+    /** Last commit hash */
+    lastCommit?: string;
+}
+/**
+ * Result of gitBranch tool
+ */
+export interface GitBranchResult {
+    /** Current branch (for list action) */
+    current?: string;
+    /** All branches (for list action) */
+    branches?: GitBranchInfo[];
+    /** Success message */
+    message: string;
+}
+/**
+ * Stash action types
+ */
+export type GitStashAction = 'push' | 'pop' | 'apply' | 'list' | 'drop' | 'clear' | 'show';
+/**
+ * Input for gitStash tool
+ */
+export interface GitStashInput {
+    /** Working directory path */
+    path?: string;
+    /** Action to perform */
+    action: GitStashAction;
+    /** Stash message (for push) */
+    message?: string;
+    /** Include untracked files (for push) */
+    includeUntracked?: boolean;
+    /** Stash index (for pop/apply/drop/show, default: 0) */
+    index?: number;
+}
+/**
+ * Stash entry info
+ */
+export interface GitStashEntry {
+    /** Stash index (0 = most recent) */
+    index: number;
+    /** Branch where stash was created */
+    branch: string;
+    /** Stash message */
+    message: string;
+    /** Stash ref (e.g., stash@{0}) */
+    ref: string;
+}
+/**
+ * Result of gitStash tool
+ */
+export interface GitStashResult {
+    /** Stash list (for list action) */
+    stashes?: GitStashEntry[];
+    /** Stash diff (for show action) */
+    diff?: string;
+    /** Success message */
+    message: string;
+}

package/dist/tools/git/types.js

@@ -0,0 +1,4 @@
+/**
+ * Types for git tools
+ */
+export {};

package/dist/tools/git/utils.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Git utilities - shared functions for git tools
+ */
+/**
+ * Result of running a git command
+ */
+export interface GitCommandResult {
+    success: boolean;
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+/**
+ * Run a git command and return the result
+ */
+export declare function runGitCommand(args: string[], options?: {
+    cwd?: string;
+    timeout?: number;
+}): Promise<GitCommandResult>;
+/**
+ * Check if a directory is a git repository
+ */
+export declare function isGitRepository(path: string): Promise<boolean>;
+/**
+ * Check if a path exists and is a directory
+ */
+export declare function isDirectory(path: string): Promise<boolean>;
+/**
+ * Parse porcelain v2 status output for a single entry
+ */
+export interface PorcelainEntry {
+    type: 'changed' | 'untracked' | 'ignored' | 'renamed' | 'copied';
+    staged: boolean;
+    path: string;
+    oldPath?: string;
+    xy: string;
+}
+/**
+ * Parse git status --porcelain=v2 output
+ */
+export declare function parsePorcelainStatus(output: string): PorcelainEntry[];
+/**
+ * Convert XY status to file status type
+ */
+export declare function xyToStatusType(xy: string, isStaged: boolean): 'added' | 'modified' | 'deleted' | 'renamed' | 'copied' | 'untracked';
+/**
+ * Parse branch info from git status --porcelain=v2 --branch output
+ */
+export interface BranchInfo {
+    branch: string;
+    upstream?: string;
+    ahead: number;
+    behind: number;
+}
+/**
+ * Parse branch headers from porcelain v2 output
+ */
+export declare function parseBranchInfo(output: string): BranchInfo;

package/dist/tools/git/utils.js

@@ -0,0 +1,197 @@
+/**
+ * Git utilities - shared functions for git tools
+ */
+import { spawn } from 'node:child_process';
+import { access, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+/**
+ * Maximum output size (50KB)
+ */
+const MAX_OUTPUT_SIZE = 50 * 1024;
+/**
+ * Run a git command and return the result
+ */
+export async function runGitCommand(args, options = {}) {
+    const { cwd = process.cwd(), timeout = 30000 } = options;
+    return new Promise((resolve) => {
+        let stdout = '';
+        let stderr = '';
+        let killed = false;
+        const proc = spawn('git', args, {
+            cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        // Timeout handler
+        const timeoutId = setTimeout(() => {
+            killed = true;
+            proc.kill('SIGTERM');
+        }, timeout);
+        proc.stdout.on('data', (data) => {
+            const chunk = data.toString();
+            if (stdout.length + chunk.length <= MAX_OUTPUT_SIZE) {
+                stdout += chunk;
+            }
+            else if (stdout.length < MAX_OUTPUT_SIZE) {
+                stdout += chunk.slice(0, MAX_OUTPUT_SIZE - stdout.length);
+                stdout += '\n... [output truncated]';
+            }
+        });
+        proc.stderr.on('data', (data) => {
+            const chunk = data.toString();
+            if (stderr.length + chunk.length <= MAX_OUTPUT_SIZE) {
+                stderr += chunk;
+            }
+        });
+        proc.on('close', (code) => {
+            clearTimeout(timeoutId);
+            if (killed) {
+                resolve({
+                    success: false,
+                    stdout,
+                    stderr: 'Command timed out',
+                    exitCode: -1,
+                });
+            }
+            else {
+                resolve({
+                    success: code === 0,
+                    stdout: stdout.trim(),
+                    stderr: stderr.trim(),
+                    exitCode: code ?? -1,
+                });
+            }
+        });
+        proc.on('error', (error) => {
+            clearTimeout(timeoutId);
+            resolve({
+                success: false,
+                stdout: '',
+                stderr: error.message,
+                exitCode: -1,
+            });
+        });
+    });
+}
+/**
+ * Check if a directory is a git repository
+ */
+export async function isGitRepository(path) {
+    try {
+        const gitDir = join(path, '.git');
+        await access(gitDir);
+        return true;
+    }
+    catch {
+        // Try running git rev-parse to check (handles worktrees)
+        const result = await runGitCommand(['rev-parse', '--git-dir'], { cwd: path });
+        return result.success;
+    }
+}
+/**
+ * Check if a path exists and is a directory
+ */
+export async function isDirectory(path) {
+    try {
+        const stats = await stat(path);
+        return stats.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Parse git status --porcelain=v2 output
+ */
+export function parsePorcelainStatus(output) {
+    const entries = [];
+    const lines = output.split('\n').filter(Boolean);
+    for (const line of lines) {
+        if (line.startsWith('1 ') || line.startsWith('2 ')) {
+            // Changed entry (1) or renamed/copied entry (2)
+            const parts = line.split(' ');
+            const xy = parts[1];
+            const isRenamed = line.startsWith('2 ');
+            if (isRenamed) {
+                // Format: 2 <XY> <sub> <mH> <mI> <mW> <hH> <hI> <X><score> <path><TAB><origPath>
+                const pathPart = parts.slice(9).join(' ');
+                const [path, oldPath] = pathPart.split('\t');
+                entries.push({
+                    type: xy[0] === 'C' ? 'copied' : 'renamed',
+                    staged: xy[0] !== '.',
+                    path,
+                    oldPath,
+                    xy,
+                });
+            }
+            else {
+                // Format: 1 <XY> <sub> <mH> <mI> <mW> <hH> <hI> <path>
+                const path = parts.slice(8).join(' ');
+                entries.push({
+                    type: 'changed',
+                    staged: xy[0] !== '.',
+                    path,
+                    xy,
+                });
+            }
+        }
+        else if (line.startsWith('? ')) {
+            // Untracked entry
+            const path = line.slice(2);
+            entries.push({
+                type: 'untracked',
+                staged: false,
+                path,
+                xy: '??',
+            });
+        }
+    }
+    return entries;
+}
+/**
+ * Convert XY status to file status type
+ */
+export function xyToStatusType(xy, isStaged) {
+    const char = isStaged ? xy[0] : xy[1];
+    switch (char) {
+        case 'A':
+            return 'added';
+        case 'M':
+            return 'modified';
+        case 'D':
+            return 'deleted';
+        case 'R':
+            return 'renamed';
+        case 'C':
+            return 'copied';
+        case '?':
+            return 'untracked';
+        default:
+            return 'modified';
+    }
+}
+/**
+ * Parse branch headers from porcelain v2 output
+ */
+export function parseBranchInfo(output) {
+    const lines = output.split('\n');
+    let branch = 'HEAD';
+    let upstream;
+    let ahead = 0;
+    let behind = 0;
+    for (const line of lines) {
+        if (line.startsWith('# branch.head ')) {
+            branch = line.slice('# branch.head '.length);
+        }
+        else if (line.startsWith('# branch.upstream ')) {
+            upstream = line.slice('# branch.upstream '.length);
+        }
+        else if (line.startsWith('# branch.ab ')) {
+            const match = line.match(/# branch\.ab \+(\d+) -(\d+)/);
+            if (match) {
+                ahead = parseInt(match[1], 10);
+                behind = parseInt(match[2], 10);
+            }
+        }
+    }
+    return { branch, upstream, ahead, behind };
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * All tools exports
+ */
+export * from './git/index.js';
+export * from './project/index.js';

package/dist/tools/index.js

@@ -0,0 +1,5 @@
+/**
+ * All tools exports
+ */
+export * from './git/index.js';
+export * from './project/index.js';

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

@@ -0,0 +1,19 @@
+/**
+ * Project Detection Tool
+ * Detects project type, package manager, and available tools
+ */
+import type { Tool } from '@compilr-dev/agents';
+import type { DetectProjectInput, ProjectDetectionRule } from './types.js';
+/**
+ * Detect project tool
+ */
+export declare const detectProjectTool: Tool<DetectProjectInput>;
+/**
+ * Factory function to create detect project tool with custom options
+ */
+export declare function createDetectProjectTool(options?: {
+    /** Base directory for relative paths */
+    baseDir?: string;
+    /** Additional project detection rules */
+    additionalRules?: ProjectDetectionRule[];
+}): Tool<DetectProjectInput>;