@devtrace-ai/cli 1.0.0

package/dist/git.js

@@ -0,0 +1,212 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitTracker = void 0;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+class GitTracker {
+    static runGitCommand(args, cwd = process.cwd()) {
+        try {
+            const result = (0, child_process_1.spawnSync)('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+            if (result.error) {
+                throw result.error;
+            }
+            if (result.status !== 0) {
+                throw new Error(`Exit code ${result.status}: ${result.stderr.trim()}`);
+            }
+            return result.stdout.trim();
+        }
+        catch (error) {
+            throw new Error(`Git command failed: git ${args.join(' ')}. Error: ${error.message}`);
+        }
+    }
+    /**
+     * Resolves the top-level repository root directory.
+     * Falls back to cwd if not inside a git repository.
+     */
+    static getRepositoryRoot(cwd = process.cwd()) {
+        try {
+            return this.runGitCommand(['rev-parse', '--show-toplevel'], cwd);
+        }
+        catch {
+            return cwd;
+        }
+    }
+    /**
+     * Resolves empty tree hash dynamically using `git hash-object --stdin`.
+     * Works on both SHA-1 and SHA-256 repositories and is fully cross-platform.
+     */
+    static getEmptyTreeHash(cwd = process.cwd()) {
+        try {
+            const result = (0, child_process_1.spawnSync)('git', ['hash-object', '-t', 'tree', '--stdin'], {
+                cwd,
+                encoding: 'utf8',
+                input: '',
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            if (result.status === 0 && result.stdout) {
+                return result.stdout.trim();
+            }
+            throw new Error(result.stderr);
+        }
+        catch {
+            // Standard fallback for SHA-1
+            return '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
+        }
+    }
+    /**
+     * Checks if the commit is a merge commit (has more than one parent).
+     */
+    static isMergeCommit(commitHash, cwd = process.cwd()) {
+        try {
+            const parentLine = this.runGitCommand(['rev-list', '--parents', '-n', '1', commitHash], cwd);
+            const commits = parentLine.split(/\s+/);
+            return commits.length > 2;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Resolves a reference (e.g. "HEAD", "HEAD~1") to a commit hash.
+     * Returns null if reference cannot be resolved.
+     */
+    static resolveRef(ref, cwd = process.cwd()) {
+        try {
+            return this.runGitCommand(['rev-parse', '--verify', ref], cwd);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Resolves a commit reference to its tree hash.
+     */
+    static getTreeHash(ref, cwd = process.cwd()) {
+        try {
+            return this.runGitCommand(['rev-parse', `${ref}^{tree}`], cwd);
+        }
+        catch {
+            return this.getEmptyTreeHash(cwd);
+        }
+    }
+    /**
+     * Returns the current branch name.
+     */
+    static getCurrentBranch(cwd = process.cwd()) {
+        try {
+            return this.runGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
+        }
+        catch {
+            return 'detached';
+        }
+    }
+    /**
+     * Retrieves metadata of a commit (author, timestamp, commit message).
+     */
+    static getCommitMetadata(commitHash, cwd = process.cwd()) {
+        try {
+            const raw = this.runGitCommand(['show', '-s', '--format=%an|%aI|%B', commitHash], cwd);
+            const parts = raw.split('|');
+            const author = parts[0] || 'Unknown';
+            const timestamp = parts[1] || new Date().toISOString();
+            const message = parts.slice(2).join('|');
+            return { author, timestamp, message };
+        }
+        catch {
+            return { author: 'Unknown', timestamp: new Date().toISOString(), message: '' };
+        }
+    }
+    /**
+     * Compares two tree/commit hashes and returns a structured DiffMetrics layout.
+     */
+    static getDiff(beforeRef, afterRef, cwd = process.cwd()) {
+        const emptyTree = this.getEmptyTreeHash(cwd);
+        const before = beforeRef || emptyTree;
+        const after = afterRef;
+        try {
+            const numstatRaw = this.runGitCommand(['diff-tree', '-r', '--no-commit-id', '--numstat', before, after], cwd);
+            const fileMetrics = new Map();
+            if (numstatRaw) {
+                const lines = numstatRaw.split('\n');
+                for (const line of lines) {
+                    const parts = line.trim().split(/\s+/);
+                    if (parts.length < 3)
+                        continue;
+                    const insRaw = parts[0];
+                    const delRaw = parts[1];
+                    const filepath = parts.slice(2).join(' ');
+                    const isBinary = insRaw === '-' || delRaw === '-';
+                    const insertions = isBinary ? 0 : parseInt(insRaw, 10);
+                    const deletions = isBinary ? 0 : parseInt(delRaw, 10);
+                    fileMetrics.set(filepath, { insertions, deletions, isBinary });
+                }
+            }
+            const files = [];
+            let totalInsertions = 0;
+            let totalDeletions = 0;
+            for (const [filepath, metrics] of fileMetrics.entries()) {
+                const ext = path.extname(filepath).toLowerCase().replace(/^\./, '');
+                files.push({
+                    path: filepath,
+                    insertions: metrics.insertions,
+                    deletions: metrics.deletions,
+                    isBinary: metrics.isBinary,
+                    language: ext || null
+                });
+                totalInsertions += metrics.insertions;
+                totalDeletions += metrics.deletions;
+            }
+            return {
+                filesChanged: files.length,
+                totalInsertions,
+                totalDeletions,
+                netLines: totalInsertions - totalDeletions,
+                files
+            };
+        }
+        catch (error) {
+            console.error(`[DevTrace] Diff calculation error: ${error.message}`);
+            return {
+                filesChanged: 0,
+                totalInsertions: 0,
+                totalDeletions: 0,
+                netLines: 0,
+                files: []
+            };
+        }
+    }
+}
+exports.GitTracker = GitTracker;

package/dist/hooks.js

@@ -0,0 +1,166 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+class HookManager {
+    static HOOK_START_MARKER = '### DEVTRACE-AI START ###';
+    static HOOK_END_MARKER = '### DEVTRACE-AI END ###';
+    /**
+     * Resolves an absolute invocation path for the currently-running DevTrace
+     * CLI (node binary + absolute script path). Baking this into the hook at
+     * install time avoids a per-commit `npx` resolution, which hits the
+     * network/registry and silently fails in GUI git clients without a
+     * PATH-aware shell.
+     */
+    static resolveInvocation() {
+        const execPath = process.execPath;
+        const scriptPath = path.resolve(require.main?.filename ?? process.argv[1]);
+        return { execPath, scriptPath };
+    }
+    static getHookScript() {
+        const { execPath, scriptPath } = this.resolveInvocation();
+        return [
+            this.HOOK_START_MARKER,
+            '# DevTrace-AI automatic commit telemetry capture',
+            '# Runs asynchronously in background to ensure zero commit delay',
+            '# Invocation path is resolved to an absolute path at install time so',
+            '# this hook never has to shell out to npx (no network/registry hit,',
+            '# works in GUI git clients without PATH hacks).',
+            '(',
+            '  REPO_DIR="$(git rev-parse --show-toplevel)"',
+            '  cd "$REPO_DIR" || exit',
+            '  mkdir -p .devtrace',
+            `  if [ -x "${scriptPath}" ] || [ -f "${scriptPath}" ]; then`,
+            `    "${execPath}" "${scriptPath}" post-commit >/dev/null 2>>.devtrace/hook.log`,
+            '  elif [ -f "dist/index.js" ]; then',
+            '    node dist/index.js post-commit >/dev/null 2>>.devtrace/hook.log',
+            '  else',
+            '    npx devtrace post-commit >/dev/null 2>>.devtrace/hook.log',
+            '  fi',
+            ') </dev/null &',
+            this.HOOK_END_MARKER
+        ].join('\n');
+    }
+    /**
+     * Resolves the active hooks directory dynamically via git rev-parse.
+     * Works correctly for standard repos, submodules, and git worktrees.
+     */
+    static getHooksDirectory(projectDir = process.cwd()) {
+        const result = (0, child_process_1.spawnSync)('git', ['rev-parse', '--git-path', 'hooks'], {
+            cwd: projectDir,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        if (result.status !== 0 || !result.stdout.trim()) {
+            throw new Error(`Directory is not a Git repository: ${projectDir}`);
+        }
+        return path.resolve(projectDir, result.stdout.trim());
+    }
+    /**
+     * Installs the post-commit git hook into the target project.
+     * Safe to run repeatedly (updates block if exists).
+     */
+    static installHook(projectDir = process.cwd()) {
+        const hooksDir = this.getHooksDirectory(projectDir);
+        if (!fs.existsSync(hooksDir)) {
+            fs.mkdirSync(hooksDir, { recursive: true });
+        }
+        const hookPath = path.join(hooksDir, 'post-commit');
+        let content = '';
+        if (fs.existsSync(hookPath)) {
+            content = fs.readFileSync(hookPath, 'utf8');
+        }
+        else {
+            content = '#!/bin/sh\n';
+        }
+        // Check if marker already exists
+        const startIndex = content.indexOf(this.HOOK_START_MARKER);
+        const endIndex = content.indexOf(this.HOOK_END_MARKER);
+        const hookCode = this.getHookScript();
+        if (startIndex !== -1 && endIndex !== -1) {
+            // Replace existing block
+            content =
+                content.substring(0, startIndex) +
+                    hookCode +
+                    content.substring(endIndex + this.HOOK_END_MARKER.length);
+        }
+        else {
+            // Append block
+            content = content.endsWith('\n') ? content + hookCode + '\n' : content + '\n' + hookCode + '\n';
+        }
+        fs.writeFileSync(hookPath, content, { encoding: 'utf8', mode: 0o755 });
+        return hookPath;
+    }
+    /**
+     * Removes only the DevTrace block from the post-commit hook.
+     */
+    static uninstallHook(projectDir = process.cwd()) {
+        let hooksDir;
+        try {
+            hooksDir = this.getHooksDirectory(projectDir);
+        }
+        catch {
+            return false; // Not a git repo or git not found
+        }
+        const hookPath = path.join(hooksDir, 'post-commit');
+        if (!fs.existsSync(hookPath)) {
+            return false;
+        }
+        let content = fs.readFileSync(hookPath, 'utf8');
+        const startIndex = content.indexOf(this.HOOK_START_MARKER);
+        const endIndex = content.indexOf(this.HOOK_END_MARKER);
+        if (startIndex === -1 || endIndex === -1) {
+            return false;
+        }
+        // Remove the block
+        content =
+            content.substring(0, startIndex).trim() +
+                '\n' +
+                content.substring(endIndex + this.HOOK_END_MARKER.length).trim();
+        content = content.trim();
+        if (content === '#!/bin/sh' || content === '') {
+            // If file contains only our hook and standard header, clean it up entirely
+            fs.unlinkSync(hookPath);
+        }
+        else {
+            fs.writeFileSync(hookPath, content + '\n', { encoding: 'utf8', mode: 0o755 });
+        }
+        return true;
+    }
+}
+exports.HookManager = HookManager;