@eduardbar/drift 0.9.0 → 1.0.0

package/dist/rules/phase3-arch.js

@@ -0,0 +1,148 @@
+import * as path from 'node:path';
+/**
+ * DFS cycle detection in a directed import graph.
+ * Returns arrays of file paths that form cycles.
+ */
+export function findCycles(graph) {
+    const visited = new Set();
+    const inStack = new Set();
+    const cycles = [];
+    function dfs(node, stack) {
+        visited.add(node);
+        inStack.add(node);
+        stack.push(node);
+        for (const neighbor of graph.get(node) ?? []) {
+            if (!visited.has(neighbor)) {
+                dfs(neighbor, stack);
+            }
+            else if (inStack.has(neighbor)) {
+                // Found a cycle — extract the cycle portion from the stack
+                const cycleStart = stack.indexOf(neighbor);
+                cycles.push(stack.slice(cycleStart));
+            }
+        }
+        stack.pop();
+        inStack.delete(node);
+    }
+    for (const node of graph.keys()) {
+        if (!visited.has(node)) {
+            dfs(node, []);
+        }
+    }
+    return cycles;
+}
+/**
+ * Detect circular dependencies from the import graph.
+ * Returns a map of filePath → issue (one per unique cycle).
+ */
+export function detectCircularDependencies(importGraph, ruleWeights) {
+    const cycles = findCycles(importGraph);
+    const reportedCycleKeys = new Set();
+    const result = new Map();
+    for (const cycle of cycles) {
+        const cycleKey = [...cycle].sort().join('|');
+        if (reportedCycleKeys.has(cycleKey))
+            continue;
+        reportedCycleKeys.add(cycleKey);
+        const firstFile = cycle[0];
+        if (!firstFile)
+            continue;
+        const cycleDisplay = cycle
+            .map(p => path.basename(p))
+            .concat(path.basename(cycle[0])) // close the loop visually: A → B → C → A
+            .join(' → ');
+        result.set(firstFile, {
+            rule: 'circular-dependency',
+            severity: ruleWeights['circular-dependency'].severity,
+            message: `Circular dependency detected: ${cycleDisplay}`,
+            line: 1,
+            column: 1,
+            snippet: cycleDisplay,
+        });
+    }
+    return result;
+}
+/**
+ * Detect layer violations based on user-defined layer configuration.
+ * Returns a map of filePath → issues[].
+ */
+export function detectLayerViolations(importGraph, layers, targetPath, ruleWeights) {
+    const result = new Map();
+    function getLayer(filePath) {
+        const rel = filePath.replace(/\\/g, '/');
+        return layers.find(layer => layer.patterns.some(pattern => {
+            const regexStr = pattern
+                .replace(/\\/g, '/')
+                .replace(/[.+^${}()|[\]]/g, '\\$&')
+                .replace(/\*\*/g, '###DOUBLESTAR###')
+                .replace(/\*/g, '[^/]*')
+                .replace(/###DOUBLESTAR###/g, '.*');
+            return new RegExp(`^${regexStr}`).test(rel);
+        }));
+    }
+    for (const [filePath, imports] of importGraph.entries()) {
+        const fileLayer = getLayer(filePath);
+        if (!fileLayer)
+            continue;
+        for (const importedPath of imports) {
+            const importedLayer = getLayer(importedPath);
+            if (!importedLayer)
+                continue;
+            if (importedLayer.name === fileLayer.name)
+                continue;
+            if (!fileLayer.canImportFrom.includes(importedLayer.name)) {
+                if (!result.has(filePath))
+                    result.set(filePath, []);
+                result.get(filePath).push({
+                    rule: 'layer-violation',
+                    severity: 'error',
+                    message: `Layer '${fileLayer.name}' must not import from layer '${importedLayer.name}'`,
+                    line: 1,
+                    column: 1,
+                    snippet: `import from '${path.relative(targetPath, importedPath).replace(/\\/g, '/')}'`,
+                });
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Detect cross-boundary imports based on user-defined module boundary configuration.
+ * Returns a map of filePath → issues[].
+ */
+export function detectCrossBoundaryImports(importGraph, modules, targetPath, ruleWeights) {
+    const result = new Map();
+    function getModule(filePath) {
+        const rel = filePath.replace(/\\/g, '/');
+        return modules.find(m => rel.startsWith(m.root.replace(/\\/g, '/')));
+    }
+    for (const [filePath, imports] of importGraph.entries()) {
+        const fileModule = getModule(filePath);
+        if (!fileModule)
+            continue;
+        for (const importedPath of imports) {
+            const importedModule = getModule(importedPath);
+            if (!importedModule)
+                continue;
+            if (importedModule.name === fileModule.name)
+                continue;
+            const allowedImports = fileModule.allowedExternalImports ?? [];
+            const relImported = importedPath.replace(/\\/g, '/');
+            const isAllowed = allowedImports.some(allowed => relImported.startsWith(allowed.replace(/\\/g, '/')));
+            if (!isAllowed) {
+                if (!result.has(filePath))
+                    result.set(filePath, []);
+                result.get(filePath).push({
+                    rule: 'cross-boundary-import',
+                    severity: 'warning',
+                    message: `Module '${fileModule.name}' must not import from module '${importedModule.name}'`,
+                    line: 1,
+                    column: 1,
+                    snippet: `import from '${path.relative(targetPath, importedPath).replace(/\\/g, '/')}'`,
+                });
+            }
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=phase3-arch.js.map

package/dist/rules/phase5-ai.d.ts

@@ -0,0 +1,8 @@
+import { SourceFile } from 'ts-morph';
+import type { DriftIssue } from '../types.js';
+export declare function detectOverCommented(file: SourceFile): DriftIssue[];
+export declare function detectHardcodedConfig(file: SourceFile): DriftIssue[];
+export declare function detectInconsistentErrorHandling(file: SourceFile): DriftIssue[];
+export declare function detectUnnecessaryAbstraction(file: SourceFile): DriftIssue[];
+export declare function detectNamingInconsistency(file: SourceFile): DriftIssue[];
+//# sourceMappingURL=phase5-ai.d.ts.map

package/dist/rules/phase5-ai.js

@@ -0,0 +1,262 @@
+// drift-ignore-file
+import { SyntaxKind } from 'ts-morph';
+export function detectOverCommented(file) {
+    const issues = [];
+    for (const fn of file.getFunctions()) {
+        const body = fn.getBody();
+        if (!body)
+            continue;
+        const bodyText = body.getText();
+        const lines = bodyText.split('\n');
+        const totalLines = lines.length;
+        if (totalLines < 6)
+            continue;
+        let commentLines = 0;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*') || trimmed.startsWith('*/')) {
+                commentLines++;
+            }
+        }
+        const ratio = commentLines / totalLines;
+        if (ratio >= 0.4) {
+            issues.push({
+                rule: 'over-commented',
+                severity: 'info',
+                message: `Function has ${Math.round(ratio * 100)}% comment density (${commentLines}/${totalLines} lines). AI documents the obvious instead of the why.`,
+                line: fn.getStartLineNumber(),
+                column: fn.getStartLinePos(),
+                snippet: fn.getName() ? `function ${fn.getName()}` : '(anonymous function)',
+            });
+        }
+    }
+    for (const cls of file.getClasses()) {
+        for (const method of cls.getMethods()) {
+            const body = method.getBody();
+            if (!body)
+                continue;
+            const bodyText = body.getText();
+            const lines = bodyText.split('\n');
+            const totalLines = lines.length;
+            if (totalLines < 6)
+                continue;
+            let commentLines = 0;
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*') || trimmed.startsWith('*/')) {
+                    commentLines++;
+                }
+            }
+            const ratio = commentLines / totalLines;
+            if (ratio >= 0.4) {
+                issues.push({
+                    rule: 'over-commented',
+                    severity: 'info',
+                    message: `Method '${method.getName()}' has ${Math.round(ratio * 100)}% comment density (${commentLines}/${totalLines} lines). AI documents the obvious instead of the why.`,
+                    line: method.getStartLineNumber(),
+                    column: method.getStartLinePos(),
+                    snippet: `${cls.getName()}.${method.getName()}`,
+                });
+            }
+        }
+    }
+    return issues;
+}
+export function detectHardcodedConfig(file) {
+    const issues = [];
+    const CONFIG_PATTERNS = [
+        { pattern: /^https?:\/\//i, label: 'HTTP/HTTPS URL' },
+        { pattern: /^wss?:\/\//i, label: 'WebSocket URL' },
+        { pattern: /^mongodb(\+srv)?:\/\//i, label: 'MongoDB connection string' },
+        { pattern: /^postgres(?:ql)?:\/\//i, label: 'PostgreSQL connection string' },
+        { pattern: /^mysql:\/\//i, label: 'MySQL connection string' },
+        { pattern: /^redis:\/\//i, label: 'Redis connection string' },
+        { pattern: /^amqps?:\/\//i, label: 'AMQP connection string' },
+        { pattern: /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/, label: 'IP address' },
+        { pattern: /^:[0-9]{2,5}$/, label: 'Port number in string' },
+        { pattern: /^\/[a-z]/i, label: 'Absolute file path' },
+        { pattern: /localhost(:[0-9]+)?/i, label: 'localhost reference' },
+    ];
+    const filePath = file.getFilePath().replace(/\\/g, '/');
+    if (filePath.includes('.test.') || filePath.includes('.spec.') || filePath.includes('__tests__')) {
+        return issues;
+    }
+    for (const node of file.getDescendantsOfKind(SyntaxKind.StringLiteral)) {
+        const value = node.getLiteralValue();
+        if (!value || value.length < 4)
+            continue;
+        const parent = node.getParent();
+        if (!parent)
+            continue;
+        const parentKind = parent.getKindName();
+        if (parentKind === 'ImportDeclaration' ||
+            parentKind === 'ExportDeclaration' ||
+            (parentKind === 'CallExpression' && parent.getText().startsWith('import(')))
+            continue;
+        for (const { pattern, label } of CONFIG_PATTERNS) {
+            if (pattern.test(value)) {
+                issues.push({
+                    rule: 'hardcoded-config',
+                    severity: 'warning',
+                    message: `Hardcoded ${label} detected. AI skips environment variables — extract to process.env or a config module.`,
+                    line: node.getStartLineNumber(),
+                    column: node.getStartLinePos(),
+                    snippet: value.length > 60 ? value.slice(0, 60) + '...' : value,
+                });
+                break;
+            }
+        }
+    }
+    return issues;
+}
+export function detectInconsistentErrorHandling(file) {
+    const issues = [];
+    let hasTryCatch = false;
+    let hasDotCatch = false;
+    let hasThenErrorHandler = false;
+    let firstLine = 0;
+    // Detectar try/catch
+    const tryCatches = file.getDescendantsOfKind(SyntaxKind.TryStatement);
+    if (tryCatches.length > 0) {
+        hasTryCatch = true;
+        firstLine = firstLine || tryCatches[0].getStartLineNumber();
+    }
+    // Detectar .catch(handler) en call expressions
+    for (const call of file.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+        const expr = call.getExpression();
+        if (expr.getKindName() === 'PropertyAccessExpression') {
+            const propAccess = expr.asKindOrThrow(SyntaxKind.PropertyAccessExpression);
+            const propName = propAccess.getName();
+            if (propName === 'catch') {
+                // Verificar que tiene al menos un argumento (handler real, no .catch() vacío)
+                if (call.getArguments().length > 0) {
+                    hasDotCatch = true;
+                    if (!firstLine)
+                        firstLine = call.getStartLineNumber();
+                }
+            }
+            // Detectar .then(onFulfilled, onRejected) — segundo argumento = error handler
+            if (propName === 'then' && call.getArguments().length >= 2) {
+                hasThenErrorHandler = true;
+                if (!firstLine)
+                    firstLine = call.getStartLineNumber();
+            }
+        }
+    }
+    const stylesUsed = [hasTryCatch, hasDotCatch, hasThenErrorHandler].filter(Boolean).length;
+    if (stylesUsed >= 2) {
+        const styles = [];
+        if (hasTryCatch)
+            styles.push('try/catch');
+        if (hasDotCatch)
+            styles.push('.catch()');
+        if (hasThenErrorHandler)
+            styles.push('.then(_, handler)');
+        issues.push({
+            rule: 'inconsistent-error-handling',
+            severity: 'warning',
+            message: `Mixed error handling styles: ${styles.join(', ')}. AI uses whatever pattern it saw last — pick one and stick to it.`,
+            line: firstLine || 1,
+            column: 1,
+            snippet: styles.join(' + '),
+        });
+    }
+    return issues;
+}
+export function detectUnnecessaryAbstraction(file) {
+    const issues = [];
+    const fileText = file.getFullText();
+    // Interfaces con un solo método
+    for (const iface of file.getInterfaces()) {
+        const methods = iface.getMethods();
+        const properties = iface.getProperties();
+        // Solo reportar si tiene exactamente 1 método y 0 propiedades (abstracción pura de comportamiento)
+        if (methods.length !== 1 || properties.length !== 0)
+            continue;
+        const ifaceName = iface.getName();
+        // Contar cuántas veces aparece el nombre en el archivo (excluyendo la declaración misma)
+        const usageCount = (fileText.match(new RegExp(`\\b${ifaceName}\\b`, 'g')) ?? []).length;
+        // La declaración misma cuenta como 1 uso, implementaciones cuentan como 1 cada una
+        // Si usageCount <= 2 (declaración + 1 uso), es candidata a innecesaria
+        if (usageCount <= 2) {
+            issues.push({
+                rule: 'unnecessary-abstraction',
+                severity: 'warning',
+                message: `Interface '${ifaceName}' has 1 method and is used only once. AI creates abstractions preemptively — YAGNI.`,
+                line: iface.getStartLineNumber(),
+                column: iface.getStartLinePos(),
+                snippet: `interface ${ifaceName} { ${methods[0].getName()}(...) }`,
+            });
+        }
+    }
+    // Clases abstractas con un solo método abstracto y sin implementaciones en el archivo
+    for (const cls of file.getClasses()) {
+        if (!cls.isAbstract())
+            continue;
+        const abstractMethods = cls.getMethods().filter(m => m.isAbstract());
+        const concreteMethods = cls.getMethods().filter(m => !m.isAbstract());
+        if (abstractMethods.length !== 1 || concreteMethods.length !== 0)
+            continue;
+        const clsName = cls.getName() ?? '';
+        const usageCount = (fileText.match(new RegExp(`\\b${clsName}\\b`, 'g')) ?? []).length;
+        if (usageCount <= 2) {
+            issues.push({
+                rule: 'unnecessary-abstraction',
+                severity: 'warning',
+                message: `Abstract class '${clsName}' has 1 abstract method and is extended nowhere in this file. AI over-engineers single-use code.`,
+                line: cls.getStartLineNumber(),
+                column: cls.getStartLinePos(),
+                snippet: `abstract class ${clsName}`,
+            });
+        }
+    }
+    return issues;
+}
+export function detectNamingInconsistency(file) {
+    const issues = [];
+    const isCamelCase = (name) => /^[a-z][a-zA-Z0-9]*$/.test(name) && /[A-Z]/.test(name);
+    const isSnakeCase = (name) => /^[a-z][a-z0-9]*(_[a-z0-9]+)+$/.test(name);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    function checkFunction(fn) {
+        const vars = fn.getVariableDeclarations();
+        if (vars.length < 3)
+            return; // muy pocas vars para ser significativo
+        let camelCount = 0;
+        let snakeCount = 0;
+        const snakeExamples = [];
+        const camelExamples = [];
+        for (const v of vars) {
+            const name = v.getName();
+            if (isCamelCase(name)) {
+                camelCount++;
+                if (camelExamples.length < 2)
+                    camelExamples.push(name);
+            }
+            else if (isSnakeCase(name)) {
+                snakeCount++;
+                if (snakeExamples.length < 2)
+                    snakeExamples.push(name);
+            }
+        }
+        if (camelCount >= 1 && snakeCount >= 1) {
+            issues.push({
+                rule: 'naming-inconsistency',
+                severity: 'warning',
+                message: `Mixed naming conventions: camelCase (${camelExamples.join(', ')}) and snake_case (${snakeExamples.join(', ')}) in the same scope. AI mixes conventions from different training examples.`,
+                line: fn.getStartLineNumber(),
+                column: fn.getStartLinePos(),
+                snippet: `camelCase: ${camelExamples[0]} / snake_case: ${snakeExamples[0]}`,
+            });
+        }
+    }
+    for (const fn of file.getFunctions()) {
+        checkFunction(fn);
+    }
+    for (const cls of file.getClasses()) {
+        for (const method of cls.getMethods()) {
+            checkFunction(method);
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=phase5-ai.js.map

package/dist/rules/phase8-semantic.d.ts

@@ -0,0 +1,22 @@
+import { SourceFile, FunctionDeclaration, ArrowFunction, FunctionExpression, MethodDeclaration } from 'ts-morph';
+import type { DriftIssue } from '../types.js';
+export type FunctionLikeNode = FunctionDeclaration | ArrowFunction | FunctionExpression | MethodDeclaration;
+/** Normalize a function body to a canonical string (Type-2 clone detection).
+ *  Variable names, parameter names, and numeric/string literals are replaced
+ *  with canonical tokens so that two functions with identical logic but
+ *  different identifiers produce the same fingerprint.
+ */
+export declare function normalizeFunctionBody(fn: FunctionLikeNode): string;
+/** Return a SHA-256 fingerprint for a function body (normalized). */
+export declare function fingerprintFunction(fn: FunctionLikeNode): string;
+export declare function collectFunctions(sf: SourceFile): Array<{
+    fn: FunctionLikeNode;
+    name: string;
+    line: number;
+    col: number;
+}>;
+export declare function calculateScore(issues: DriftIssue[], ruleWeights: Record<string, {
+    severity: DriftIssue['severity'];
+    weight: number;
+}>): number;
+//# sourceMappingURL=phase8-semantic.d.ts.map

package/dist/rules/phase8-semantic.js

@@ -0,0 +1,109 @@
+import * as crypto from 'node:crypto';
+import { SyntaxKind, } from 'ts-morph';
+/** Normalize a function body to a canonical string (Type-2 clone detection).
+ *  Variable names, parameter names, and numeric/string literals are replaced
+ *  with canonical tokens so that two functions with identical logic but
+ *  different identifiers produce the same fingerprint.
+ */
+export function normalizeFunctionBody(fn) {
+    // Build a substitution map: localName → canonical token
+    const subst = new Map();
+    // Map parameters first
+    for (const [i, param] of fn.getParameters().entries()) {
+        const name = param.getName();
+        if (name && name !== '_')
+            subst.set(name, `P${i}`);
+    }
+    // Map locally declared variables (VariableDeclaration)
+    let varIdx = 0;
+    fn.forEachDescendant(node => {
+        if (node.getKind() === SyntaxKind.VariableDeclaration) {
+            const nameNode = node.getNameNode();
+            // Support destructuring — getNameNode() may be a BindingPattern
+            if (nameNode.getKind() === SyntaxKind.Identifier) {
+                const name = nameNode.getText();
+                if (!subst.has(name))
+                    subst.set(name, `V${varIdx++}`);
+            }
+        }
+    });
+    function serializeNode(node) {
+        const kind = node.getKindName();
+        switch (node.getKind()) {
+            case SyntaxKind.Identifier: {
+                const text = node.getText();
+                return subst.get(text) ?? text; // external refs (Math, console) kept as-is
+            }
+            case SyntaxKind.NumericLiteral:
+                return 'NL';
+            case SyntaxKind.StringLiteral:
+            case SyntaxKind.NoSubstitutionTemplateLiteral:
+                return 'SL';
+            case SyntaxKind.TrueKeyword:
+                return 'TRUE';
+            case SyntaxKind.FalseKeyword:
+                return 'FALSE';
+            case SyntaxKind.NullKeyword:
+                return 'NULL';
+        }
+        const children = node.getChildren();
+        if (children.length === 0)
+            return kind;
+        const childStr = children.map(serializeNode).join('|');
+        return `${kind}(${childStr})`;
+    }
+    const body = fn.getBody();
+    if (!body)
+        return '';
+    return serializeNode(body);
+}
+/** Return a SHA-256 fingerprint for a function body (normalized). */
+export function fingerprintFunction(fn) {
+    const normalized = normalizeFunctionBody(fn);
+    return crypto.createHash('sha256').update(normalized).digest('hex');
+}
+/** Return all function-like nodes from a SourceFile that are worth comparing:
+ *  - At least MIN_LINES lines in their body
+ *  - Not test helpers (describe/it/test/beforeEach/afterEach)
+ */
+const MIN_LINES = 8;
+export function collectFunctions(sf) {
+    const results = [];
+    const kinds = [
+        SyntaxKind.FunctionDeclaration,
+        SyntaxKind.FunctionExpression,
+        SyntaxKind.ArrowFunction,
+        SyntaxKind.MethodDeclaration,
+    ];
+    for (const kind of kinds) {
+        for (const node of sf.getDescendantsOfKind(kind)) {
+            const body = node.getBody();
+            if (!body)
+                continue;
+            const start = body.getStartLineNumber();
+            const end = body.getEndLineNumber();
+            if (end - start + 1 < MIN_LINES)
+                continue;
+            // Skip test-framework helpers
+            const name = node.getKind() === SyntaxKind.FunctionDeclaration
+                ? node.getName() ?? '<anonymous>'
+                : node.getKind() === SyntaxKind.MethodDeclaration
+                    ? node.getName()
+                    : '<anonymous>';
+            if (['describe', 'it', 'test', 'beforeEach', 'afterEach', 'beforeAll', 'afterAll'].includes(name))
+                continue;
+            const pos = node.getStart();
+            const lineInfo = sf.getLineAndColumnAtPos(pos);
+            results.push({ fn: node, name, line: lineInfo.line, col: lineInfo.column });
+        }
+    }
+    return results;
+}
+export function calculateScore(issues, ruleWeights) {
+    let raw = 0;
+    for (const issue of issues) {
+        raw += ruleWeights[issue.rule]?.weight ?? 5;
+    }
+    return Math.min(100, raw);
+}
+//# sourceMappingURL=phase8-semantic.js.map

package/dist/rules/shared.d.ts

@@ -0,0 +1,7 @@
+import { SourceFile, Node, FunctionDeclaration, ArrowFunction, FunctionExpression, MethodDeclaration } from 'ts-morph';
+export type FunctionLike = FunctionDeclaration | ArrowFunction | FunctionExpression | MethodDeclaration;
+export declare function hasIgnoreComment(file: SourceFile, line: number): boolean;
+export declare function isFileIgnored(file: SourceFile): boolean;
+export declare function getSnippet(node: Node, file: SourceFile): string;
+export declare function getFunctionLikeLines(node: FunctionLike): number;
+//# sourceMappingURL=shared.d.ts.map

package/dist/rules/shared.js

@@ -0,0 +1,27 @@
+export function hasIgnoreComment(file, line) {
+    const lines = file.getFullText().split('\n');
+    const currentLine = lines[line - 1] ?? '';
+    const prevLine = lines[line - 2] ?? '';
+    if (/\/\/\s*drift-ignore\b/.test(currentLine))
+        return true;
+    if (/\/\/\s*drift-ignore\b/.test(prevLine))
+        return true;
+    return false;
+}
+export function isFileIgnored(file) {
+    const firstLines = file.getFullText().split('\n').slice(0, 10).join('\n'); // drift-ignore
+    return /\/\/\s*drift-ignore-file\b/.test(firstLines);
+}
+export function getSnippet(node, file) {
+    const startLine = node.getStartLineNumber();
+    const lines = file.getFullText().split('\n');
+    return lines
+        .slice(Math.max(0, startLine - 1), startLine + 1)
+        .join('\n')
+        .trim()
+        .slice(0, 120); // drift-ignore
+}
+export function getFunctionLikeLines(node) {
+    return node.getEndLineNumber() - node.getStartLineNumber();
+}
+//# sourceMappingURL=shared.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eduardbar/drift",
-  "version": "0.9.0",
+  "version": "1.0.0",
   "description": "Detect silent technical debt left by AI-generated code",
   "type": "module",
   "main": "dist/index.js",
@@ -11,7 +11,10 @@
     "build": "tsc",
     "dev": "tsc --watch",
     "start": "node dist/cli.js",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
   },
   "keywords": [
     "vibe-coding",
@@ -38,6 +41,8 @@
   },
   "devDependencies": {
     "@types/node": "^25.3.0",
-    "typescript": "^5.9.3"
+    "@vitest/coverage-v8": "^4.0.18",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
   }
 }

package/packages/vscode-drift/.vscodeignore

@@ -0,0 +1,9 @@
+.vscode/**
+src/**
+node_modules/**
+**/*.map
+**/*.ts
+!**/*.d.ts
+tsconfig.json
+.gitignore
+images/*.svg

package/packages/vscode-drift/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Eduard Barrera
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.