@devtrace-ai/cli 1.0.0

package/dist/config.js

@@ -0,0 +1,174 @@
+"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.GlobalConfigManager = exports.ConfigManager = exports.DEFAULT_CONFIG = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+exports.DEFAULT_CONFIG = {
+    storageDir: '.devtrace',
+    testCommand: null,
+    chatLogPath: null,
+    autoGitIgnore: true,
+    runTestsAsync: true,
+};
+class ConfigManager {
+    static configFileName = 'devtrace.config.json';
+    /**
+     * Load DevTrace config from the repository root.
+     * If config doesn't exist, returns the default configuration.
+     */
+    static loadConfig(projectDir = process.cwd()) {
+        const configPath = path.join(projectDir, this.configFileName);
+        if (!fs.existsSync(configPath)) {
+            return exports.DEFAULT_CONFIG;
+        }
+        try {
+            const content = fs.readFileSync(configPath, 'utf8');
+            const parsed = JSON.parse(content);
+            return this.validateAndNormalize(parsed);
+        }
+        catch (error) {
+            console.warn(`[DevTrace] Failed to parse config file: ${error.message}. Using defaults.`);
+            return exports.DEFAULT_CONFIG;
+        }
+    }
+    /**
+     * Write config to project root.
+     */
+    static saveConfig(config, projectDir = process.cwd()) {
+        const configPath = path.join(projectDir, this.configFileName);
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+        if (config.autoGitIgnore) {
+            this.ensureGitIgnore(config.storageDir, projectDir);
+        }
+    }
+    /**
+     * Safely adds the storage directory to the local .gitignore if autoGitIgnore is enabled.
+     */
+    static ensureGitIgnore(storageDir, projectDir) {
+        const gitignorePath = path.join(projectDir, '.gitignore');
+        try {
+            let content = '';
+            if (fs.existsSync(gitignorePath)) {
+                content = fs.readFileSync(gitignorePath, 'utf8');
+            }
+            // Check if already in gitignore
+            const lines = content.split(/\r?\n/);
+            const isIgnored = lines.some(line => line.trim() === storageDir || line.trim() === `${storageDir}/`);
+            if (!isIgnored) {
+                const separator = content.endsWith('\n') || content === '' ? '' : '\n';
+                fs.appendFileSync(gitignorePath, `${separator}# DevTrace dataset directory\n${storageDir}/\n`, 'utf8');
+            }
+        }
+        catch (error) {
+            console.error(`[DevTrace] Failed to update .gitignore: ${error.message}`);
+        }
+    }
+    /**
+     * Ensures the loaded config satisfies key types and sets fallbacks for missing fields.
+     */
+    static validateAndNormalize(parsed) {
+        return {
+            storageDir: typeof parsed.storageDir === 'string' ? parsed.storageDir : exports.DEFAULT_CONFIG.storageDir,
+            testCommand: typeof parsed.testCommand === 'string' || parsed.testCommand === null ? parsed.testCommand : exports.DEFAULT_CONFIG.testCommand,
+            chatLogPath: typeof parsed.chatLogPath === 'string' || parsed.chatLogPath === null ? parsed.chatLogPath : exports.DEFAULT_CONFIG.chatLogPath,
+            autoGitIgnore: typeof parsed.autoGitIgnore === 'boolean' ? parsed.autoGitIgnore : exports.DEFAULT_CONFIG.autoGitIgnore,
+            runTestsAsync: typeof parsed.runTestsAsync === 'boolean' ? parsed.runTestsAsync : exports.DEFAULT_CONFIG.runTestsAsync,
+        };
+    }
+}
+exports.ConfigManager = ConfigManager;
+class GlobalConfigManager {
+    /**
+     * Resolves the directory used for global (cross-project) DevTrace state.
+     * Honors DEVTRACE_HOME as an override so tests (and users who want an
+     * isolated config) never touch the real ~/.devtrace.
+     */
+    static getGlobalConfigDir() {
+        if (process.env.DEVTRACE_HOME) {
+            return process.env.DEVTRACE_HOME;
+        }
+        const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+        return path.join(homeDir, '.devtrace');
+    }
+    static getGlobalConfigPath() {
+        return path.join(this.getGlobalConfigDir(), 'global_config.json');
+    }
+    static load() {
+        const filePath = this.getGlobalConfigPath();
+        if (!fs.existsSync(filePath)) {
+            return { trustedWorkspaces: [] };
+        }
+        try {
+            const content = fs.readFileSync(filePath, 'utf8');
+            const parsed = JSON.parse(content);
+            return {
+                trustedWorkspaces: Array.isArray(parsed.trustedWorkspaces) ? parsed.trustedWorkspaces : []
+            };
+        }
+        catch {
+            return { trustedWorkspaces: [] };
+        }
+    }
+    static save(config) {
+        const filePath = this.getGlobalConfigPath();
+        const dir = path.dirname(filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(filePath, JSON.stringify(config, null, 2), 'utf8');
+    }
+    static isWorkspaceTrusted(projectDir = process.cwd()) {
+        const config = this.load();
+        const resolvedPath = path.resolve(projectDir).toLowerCase();
+        return config.trustedWorkspaces.some(w => path.resolve(w).toLowerCase() === resolvedPath);
+    }
+    static trustWorkspace(projectDir = process.cwd()) {
+        const config = this.load();
+        const resolvedPath = path.resolve(projectDir);
+        const resolvedPathLower = resolvedPath.toLowerCase();
+        if (!config.trustedWorkspaces.some(w => path.resolve(w).toLowerCase() === resolvedPathLower)) {
+            config.trustedWorkspaces.push(resolvedPath);
+            this.save(config);
+        }
+    }
+    static untrustWorkspace(projectDir = process.cwd()) {
+        const config = this.load();
+        const resolvedPath = path.resolve(projectDir).toLowerCase();
+        config.trustedWorkspaces = config.trustedWorkspaces.filter(w => path.resolve(w).toLowerCase() !== resolvedPath);
+        this.save(config);
+    }
+}
+exports.GlobalConfigManager = GlobalConfigManager;

package/dist/core/scan.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanCommitHistory = scanCommitHistory;
+const child_process_1 = require("child_process");
+const trailers_1 = require("../capture/trailers");
+const metrics_1 = require("../metrics");
+// Field/record delimiters chosen to never collide with real commit content.
+// Commit messages can contain anything except NUL, but they realistically never
+// contain the ASCII "record separator" (0x1e) or "unit separator" (0x1f) control
+// characters, so we use those instead of trying to escape arbitrary message bytes.
+const RECORD_SEP = '\x1e';
+const FIELD_SEP = '\x1f';
+const GIT_LOG_FORMAT = `${RECORD_SEP}%H${FIELD_SEP}%an${FIELD_SEP}%aI${FIELD_SEP}%P${FIELD_SEP}%B${RECORD_SEP}`;
+// Same heuristic weights/caps as AIDetector's tier-3 logic (src/detector.ts). Duplicated here
+// (rather than calling AIDetector.detect) because that method spawns `git show`/`git rev-parse`
+// per commit for metadata + parent lookup — exactly the per-commit-spawn cost Pass 1 must avoid.
+// We already have author/timestamp/parent from the single streamed log, so we replicate the
+// pure scoring logic in-memory instead.
+const HEURISTIC_SIGNAL_CAP = 0.25;
+const HEURISTIC_TIER_CAP = 0.5;
+const TRAILER_CONFIDENCE = 0.95;
+const UNKNOWN_MAX_CONFIDENCE = 0.3;
+const VELOCITY_THRESHOLD_SECONDS = 45;
+const VELOCITY_MIN_LINES = 20;
+const GREENFIELD_MIN_INSERTIONS = 150;
+/**
+ * In-memory equivalent of AIDetector.detect's tier-3 heuristics, taking the parent commit's
+ * timestamp directly instead of spawning git to look it up. Tier-1 trailer matching is
+ * identical to AIDetector (delegates to the same TrailerParser).
+ */
+function classifyCommit(commitHash, authorName, message, diff, authorDate, parentDate) {
+    const reasons = [];
+    // --- Tier 1: confirmed trailer match(es) ---
+    const trailerMatches = trailers_1.TrailerParser.parse(message, authorName);
+    if (trailerMatches.length > 0) {
+        const primary = trailerMatches[0];
+        for (const match of trailerMatches) {
+            const suffix = match.model ? ` (model: ${match.model})` : '';
+            reasons.push(`${match.pattern}${match.unverified ? ' [unverified-pattern]' : ''}${suffix}`);
+        }
+        return { tool: primary.tool, confidence: TRAILER_CONFIDENCE, tier: 1, reasons };
+    }
+    // --- Tier 3: heuristic weak priors ---
+    let heuristicScore = 0;
+    let heuristicFired = false;
+    if (parentDate) {
+        const commitTime = new Date(authorDate).getTime();
+        const parentTime = new Date(parentDate).getTime();
+        const diffSeconds = (commitTime - parentTime) / 1000;
+        if (diffSeconds > 0 && diffSeconds < VELOCITY_THRESHOLD_SECONDS) {
+            const linesChanged = diff.totalInsertions + diff.totalDeletions;
+            if (linesChanged > VELOCITY_MIN_LINES) {
+                heuristicFired = true;
+                heuristicScore += Math.min(HEURISTIC_SIGNAL_CAP, 0.2);
+                reasons.push(`heuristic:velocity (${diffSeconds.toFixed(1)}s < ${VELOCITY_THRESHOLD_SECONDS}s threshold, ${linesChanged} lines changed)`);
+            }
+        }
+    }
+    if (diff.totalInsertions > GREENFIELD_MIN_INSERTIONS && diff.totalDeletions === 0) {
+        heuristicFired = true;
+        heuristicScore += Math.min(HEURISTIC_SIGNAL_CAP, 0.2);
+        reasons.push(`heuristic:greenfield (${diff.totalInsertions} insertions, 0 deletions)`);
+    }
+    if (heuristicFired) {
+        return { tool: 'unknown-ai', confidence: Math.min(HEURISTIC_TIER_CAP, heuristicScore), tier: 3, reasons };
+    }
+    reasons.push('tier0:no-signal');
+    return { tool: 'none', confidence: UNKNOWN_MAX_CONFIDENCE, tier: 0, reasons };
+}
+/**
+ * Parses a single numstat block (lines following a commit header, up to the next RECORD_SEP)
+ * into a DiffMetrics. Handles binary files ("-\t-\tpath") and rename lines
+ * ("old.ts => new.ts" or the "{old => new}/rest.ts" braced form).
+ */
+function parseNumstatBlock(lines, ignoreFilter) {
+    const files = [];
+    let totalInsertions = 0;
+    let totalDeletions = 0;
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        const tabParts = line.split('\t');
+        if (tabParts.length < 3)
+            continue;
+        const insRaw = tabParts[0];
+        const delRaw = tabParts[1];
+        const pathField = tabParts.slice(2).join('\t');
+        const filepath = resolveRenamedPath(pathField);
+        if (ignoreFilter && ignoreFilter.shouldIgnore(filepath)) {
+            continue;
+        }
+        const isBinary = insRaw === '-' || delRaw === '-';
+        const insertions = isBinary ? 0 : parseInt(insRaw, 10) || 0;
+        const deletions = isBinary ? 0 : parseInt(delRaw, 10) || 0;
+        const dotIdx = filepath.lastIndexOf('.');
+        const slashIdx = filepath.lastIndexOf('/');
+        const ext = dotIdx > slashIdx ? filepath.substring(dotIdx + 1).toLowerCase() : '';
+        files.push({
+            path: filepath,
+            insertions,
+            deletions,
+            isBinary,
+            language: ext || null
+        });
+        totalInsertions += insertions;
+        totalDeletions += deletions;
+    }
+    return {
+        filesChanged: files.length,
+        totalInsertions,
+        totalDeletions,
+        netLines: totalInsertions - totalDeletions,
+        files
+    };
+}
+/**
+ * Resolves numstat's rename path notations to the post-rename (current) path:
+ *   "old.ts => new.ts"                  -> "new.ts"
+ *   "src/{old => new}/file.ts"          -> "src/new/file.ts"
+ *   "plain/unchanged/path.ts"           -> unchanged
+ */
+function resolveRenamedPath(pathField) {
+    const braceMatch = pathField.match(/^(.*)\{(.*) => (.*)\}(.*)$/);
+    if (braceMatch) {
+        const [, prefix, , after, suffix] = braceMatch;
+        return `${prefix}${after}${suffix}`;
+    }
+    const simpleArrow = pathField.split(' => ');
+    if (simpleArrow.length === 2) {
+        return simpleArrow[1].trim();
+    }
+    return pathField;
+}
+/**
+ * Pass 1 of the retroactive scan: a single streamed `git log` subprocess covering the
+ * requested window, parsed incrementally into classified ScannedCommit records.
+ * No per-commit git spawns — velocity heuristic uses consecutive commit timestamps
+ * already present in the stream (parent lookup by hash, not by re-invoking git).
+ */
+function scanCommitHistory(options = {}) {
+    const cwd = options.cwd || process.cwd();
+    const since = options.since || '90 days ago';
+    const ignoreFilter = options.ignoreFilter;
+    return new Promise((resolve, reject) => {
+        const args = [
+            'log',
+            `--since=${since}`,
+            '--no-merges',
+            '--numstat',
+            '--date=iso-strict',
+            `--format=${GIT_LOG_FORMAT}`,
+            'HEAD'
+        ];
+        const child = (0, child_process_1.spawn)('git', args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+        let buffer = '';
+        let stderr = '';
+        const rawCommits = [];
+        // Each commit record is bracketed by RECORD_SEP on both sides:
+        //   RS H \x1f an \x1f aI \x1f P \x1f B RS \n\n <numstat lines...>
+        // and the numstat lines run until the *next* record's opening RECORD_SEP. So splitting
+        // the whole stream on RECORD_SEP yields, in order: [leading-junk, header1, numstat1,
+        // header2, numstat2, ...] — odd-indexed segments (1-based pairs starting at index 1)
+        // are headers, the segment immediately after each header is that same commit's numstat.
+        let pendingHeader = null;
+        function consumeBuffer(finalFlush) {
+            let idx;
+            // Keep the last (possibly incomplete) segment in `buffer` unless this is the final flush.
+            while ((idx = buffer.indexOf(RECORD_SEP)) !== -1) {
+                const segment = buffer.substring(0, idx);
+                buffer = buffer.substring(idx + 1);
+                consumeSegment(segment);
+            }
+            if (finalFlush && buffer.length > 0) {
+                consumeSegment(buffer);
+                buffer = '';
+            }
+        }
+        function consumeSegment(segment) {
+            if (pendingHeader === null) {
+                // This segment is a header (or leading junk before the first header).
+                const fields = segment.split(FIELD_SEP);
+                if (fields.length < 5) {
+                    return; // leading junk / malformed — not a header, stay in header-seeking state
+                }
+                const [hash, authorName, authorDate, parents, ...messageParts] = fields;
+                pendingHeader = {
+                    hash: hash.trim(),
+                    authorName: authorName.trim(),
+                    authorDate: authorDate.trim(),
+                    parentHashes: parents.trim().length > 0 ? parents.trim().split(/\s+/) : [],
+                    message: messageParts.join(FIELD_SEP)
+                };
+            }
+            else {
+                // This segment is the numstat block belonging to pendingHeader.
+                const numstatLines = segment
+                    .split('\n')
+                    .map(l => l.trim())
+                    .filter(l => l.length > 0);
+                rawCommits.push({ ...pendingHeader, numstatLines });
+                pendingHeader = null;
+            }
+        }
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', (data) => {
+            buffer += data;
+            consumeBuffer(false);
+            if (options.onProgress) {
+                options.onProgress(rawCommits.length);
+            }
+        });
+        child.stderr.setEncoding('utf8');
+        child.stderr.on('data', (data) => {
+            stderr += data;
+        });
+        child.on('error', (err) => reject(err));
+        child.on('close', (code) => {
+            consumeBuffer(true);
+            if (code !== 0 && rawCommits.length === 0) {
+                // Empty repo / no commits in window is not an error; only reject on genuine failures
+                // where git produced neither output nor commits.
+                if (stderr.trim().length > 0) {
+                    reject(new Error(`git log failed (exit ${code}): ${stderr.trim()}`));
+                    return;
+                }
+            }
+            // git log emits newest-first; reverse to oldest-first so parent-date lookups
+            // (needed for the velocity heuristic) can use a simple hash map built as we go,
+            // and so downstream consumers see a natural chronological order.
+            const chronological = rawCommits.slice().reverse();
+            const dateByHash = new Map();
+            for (const rc of chronological) {
+                dateByHash.set(rc.hash, rc.authorDate);
+            }
+            const commits = [];
+            for (const rc of chronological) {
+                const diff = parseNumstatBlock(rc.numstatLines, ignoreFilter);
+                // Skip commits that touched nothing but ignored paths (mirrors post-commit hook behavior).
+                if (rc.numstatLines.length > 0 && diff.filesChanged === 0) {
+                    continue;
+                }
+                const parentHash = rc.parentHashes[0] || '';
+                const parentDate = parentHash ? dateByHash.get(parentHash) || null : null;
+                const classification = classifyCommit(rc.hash, rc.authorName, rc.message, diff, rc.authorDate, parentDate);
+                const changeType = metrics_1.MetricsClassifier.classify(diff, rc.message);
+                commits.push({
+                    commitHash: rc.hash,
+                    parentHash,
+                    authorName: rc.authorName,
+                    authorDate: rc.authorDate,
+                    message: rc.message,
+                    diff,
+                    aiTool: classification.tool,
+                    aiToolConfidence: classification.confidence,
+                    aiToolTier: classification.tier,
+                    reasons: classification.reasons,
+                    changeType: changeType.changeType,
+                    changeTypeConfidence: changeType.confidence
+                });
+            }
+            resolve({ commits, totalCommitsSeen: rawCommits.length });
+        });
+    });
+}