distyll 0.1.0

package/tests/e2e.test.ts

@@ -0,0 +1,163 @@
+import { describe, it, expect } from 'vitest';
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+const CLI_PATH = path.resolve(__dirname, '../dist/cli.js');
+
+function run(args: string, opts?: { cwd?: string; expectFail?: boolean }): string {
+  try {
+    return execSync(`node ${CLI_PATH} ${args}`, {
+      cwd: opts?.cwd ?? process.cwd(),
+      encoding: 'utf-8',
+      env: { ...process.env, FORCE_COLOR: '0' },
+      timeout: 30000,
+    });
+  } catch (err: any) {
+    if (opts?.expectFail) {
+      return (err.stdout ?? '') + (err.stderr ?? '');
+    }
+    throw err;
+  }
+}
+
+function createTempProject(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'distyll-e2e-'));
+  return dir;
+}
+
+describe('CLI end-to-end', () => {
+  it('--version outputs version number', () => {
+    const output = run('--version');
+    expect(output.trim()).toMatch(/^\d+\.\d+\.\d+$/);
+  });
+
+  it('--help shows usage', () => {
+    const output = run('--help');
+    expect(output).toContain('distyll');
+    expect(output).toContain('scan');
+    expect(output).toContain('diff');
+    expect(output).toContain('hook');
+    expect(output).toContain('ci');
+    expect(output).toContain('init');
+    expect(output).toContain('fingerprint');
+  });
+
+  it('scan --help shows scan options', () => {
+    const output = run('scan --help');
+    expect(output).toContain('--format');
+    expect(output).toContain('--threshold');
+    expect(output).toContain('--style');
+    expect(output).toContain('--verbose');
+    expect(output).toContain('--quiet');
+  });
+});
+
+describe('scan command', () => {
+  it('scans a clean file and reports score 0', () => {
+    const dir = createTempProject();
+    fs.writeFileSync(
+      path.join(dir, 'clean.js'),
+      'function add(a, b) {\n  return a + b;\n}\n\nconst result = add(1, 2);\nconsole.log(result);\n'
+    );
+    const output = run(`scan ${dir}`);
+    expect(output).toContain('Slop Score');
+    expect(output).toContain('0/100');
+  });
+
+  it('detects slop in a file with wrapper function', () => {
+    const dir = createTempProject();
+    fs.writeFileSync(
+      path.join(dir, 'sloppy.js'),
+      'function wrapper(x) {\n  return doThing(x);\n}\n'
+    );
+    const output = run(`scan ${dir}`);
+    expect(output).toContain('single-use-wrapper');
+  });
+
+  it('--format json outputs valid JSON', () => {
+    const dir = createTempProject();
+    fs.writeFileSync(path.join(dir, 'test.js'), 'const x = 1;\n');
+    const output = run(`scan ${dir} --format json`);
+    const parsed = JSON.parse(output);
+    expect(parsed).toHaveProperty('score');
+    expect(parsed).toHaveProperty('totalFindings');
+    expect(parsed).toHaveProperty('files');
+  });
+
+  it('--quiet outputs only the score number', () => {
+    const dir = createTempProject();
+    fs.writeFileSync(path.join(dir, 'test.js'), 'const x = 1;\n');
+    const output = run(`scan ${dir} --quiet`);
+    expect(output.trim()).toMatch(/^\d+$/);
+  });
+
+  it('--threshold exits with code 1 when exceeded', () => {
+    const dir = createTempProject();
+    fs.writeFileSync(
+      path.join(dir, 'sloppy.js'),
+      'function wrapper(x) {\n  return doThing(x);\n}\n'
+    );
+    const output = run(`scan ${dir} --threshold 0`, { expectFail: true });
+    expect(output).toContain('exceeds threshold');
+  });
+
+  it('scans Python files', () => {
+    const dir = createTempProject();
+    fs.writeFileSync(
+      path.join(dir, 'test.py'),
+      'def add(a, b):\n    return a + b\n\nresult = add(1, 2)\nprint(result)\n'
+    );
+    const output = run(`scan ${dir}`);
+    expect(output).toContain('Slop Score');
+  });
+});
+
+describe('init command', () => {
+  it('creates .distyll.json and .distyll/ directory', () => {
+    const dir = createTempProject();
+    const output = run(`init ${dir}`);
+    expect(output).toContain('.distyll.json');
+    expect(fs.existsSync(path.join(dir, '.distyll.json'))).toBe(true);
+    expect(fs.existsSync(path.join(dir, '.distyll'))).toBe(true);
+  });
+
+  it('does not overwrite existing config', () => {
+    const dir = createTempProject();
+    const configPath = path.join(dir, '.distyll.json');
+    fs.writeFileSync(configPath, '{"custom": true}');
+    const output = run(`init ${dir}`);
+    expect(output).toContain('already exists');
+    expect(fs.readFileSync(configPath, 'utf-8')).toBe('{"custom": true}');
+  });
+});
+
+describe('fingerprint command', () => {
+  it('creates a style profile from a codebase', () => {
+    const dir = createTempProject();
+    fs.writeFileSync(
+      path.join(dir, 'sample.js'),
+      [
+        'function calculateTotal(items) {',
+        '  let total = 0;',
+        '  for (const item of items) {',
+        '    total += item.price;',
+        '  }',
+        '  return total;',
+        '}',
+        '',
+        'function formatCurrency(amount) {',
+        '  return "$" + amount.toFixed(2);',
+        '}',
+        '',
+      ].join('\n')
+    );
+    run(`fingerprint ${dir}`);
+    const profilePath = path.join(dir, '.distyll', 'profile.json');
+    expect(fs.existsSync(profilePath)).toBe(true);
+    const profile = JSON.parse(fs.readFileSync(profilePath, 'utf-8'));
+    expect(profile).toHaveProperty('metrics');
+    expect(profile.metrics).toHaveProperty('medianFunctionLength');
+  });
+});

package/tests/edge-cases.test.ts

@@ -0,0 +1,167 @@
+import { describe, it, expect } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { scanFile, scanPaths } from '../src/scanner';
+import { isBinaryBuffer, safeReadFile, formatError, DistyllError } from '../src/errors';
+
+function createTempDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'distyll-edge-'));
+}
+
+function createTempFile(content: string | Buffer, ext: string, dir?: string): string {
+  const d = dir ?? createTempDir();
+  const filePath = path.join(d, `test${ext}`);
+  fs.writeFileSync(filePath, content);
+  return filePath;
+}
+
+describe('binary file detection', () => {
+  it('detects binary files with null bytes', () => {
+    const buf = Buffer.from([0x48, 0x65, 0x6c, 0x00, 0x6f]);
+    expect(isBinaryBuffer(buf)).toBe(true);
+  });
+
+  it('does not flag text files as binary', () => {
+    const buf = Buffer.from('function hello() { return "world"; }');
+    expect(isBinaryBuffer(buf)).toBe(false);
+  });
+
+  it('scanFile returns null for binary files', () => {
+    const binaryContent = Buffer.alloc(100);
+    binaryContent[50] = 0;
+    binaryContent.write('function foo() {}', 0);
+    const filePath = createTempFile(binaryContent, '.js');
+    expect(scanFile(filePath)).toBeNull();
+  });
+});
+
+describe('empty file handling', () => {
+  it('scanFile returns null for empty files', () => {
+    const filePath = createTempFile('', '.js');
+    expect(scanFile(filePath)).toBeNull();
+  });
+
+  it('scanPaths handles empty directory gracefully', async () => {
+    const dir = createTempDir();
+    const summary = await scanPaths([dir]);
+    expect(summary.score).toBe(0);
+    expect(summary.totalFindings).toBe(0);
+    expect(summary.results).toHaveLength(0);
+  });
+});
+
+describe('unsupported languages', () => {
+  it('scanFile returns null for .txt files', () => {
+    const filePath = createTempFile('hello world', '.txt');
+    expect(scanFile(filePath)).toBeNull();
+  });
+
+  it('scanFile returns null for .rs files', () => {
+    const filePath = createTempFile('fn main() {}', '.rs');
+    expect(scanFile(filePath)).toBeNull();
+  });
+
+  it('scanFile returns null for .go files', () => {
+    const filePath = createTempFile('package main', '.go');
+    expect(scanFile(filePath)).toBeNull();
+  });
+
+  it('scanPaths skips unsupported files in mixed directory', async () => {
+    const dir = createTempDir();
+    fs.writeFileSync(path.join(dir, 'a.js'), 'const x = 1;\n');
+    fs.writeFileSync(path.join(dir, 'b.txt'), 'not code');
+    fs.writeFileSync(path.join(dir, 'c.md'), '# readme');
+    const summary = await scanPaths([dir]);
+    expect(summary.results).toHaveLength(1);
+  });
+});
+
+describe('nonexistent paths', () => {
+  it('scanPaths skips nonexistent paths without crashing', async () => {
+    const summary = await scanPaths(['/tmp/does-not-exist-distyll-test']);
+    expect(summary.score).toBe(0);
+    expect(summary.results).toHaveLength(0);
+  });
+
+  it('scanFile returns null for nonexistent files', () => {
+    expect(scanFile('/tmp/does-not-exist-distyll-test.js')).toBeNull();
+  });
+});
+
+describe('safeReadFile', () => {
+  it('returns source for valid text files', () => {
+    const filePath = createTempFile('const x = 1;', '.js');
+    const result = safeReadFile(filePath);
+    expect(result).not.toBeNull();
+    expect(result!.source).toBe('const x = 1;');
+  });
+
+  it('returns null for nonexistent files', () => {
+    expect(safeReadFile('/tmp/no-such-file-distyll.js')).toBeNull();
+  });
+
+  it('returns null for empty files', () => {
+    const filePath = createTempFile('', '.js');
+    expect(safeReadFile(filePath)).toBeNull();
+  });
+
+  it('returns null for binary files', () => {
+    const buf = Buffer.alloc(20);
+    buf[10] = 0;
+    const filePath = createTempFile(buf, '.js');
+    expect(safeReadFile(filePath)).toBeNull();
+  });
+});
+
+describe('error formatting', () => {
+  it('formats DistyllError with hint', () => {
+    const err = new DistyllError('Something failed', 'Try running with --verbose');
+    const msg = formatError(err);
+    expect(msg).toContain('Something failed');
+    expect(msg).toContain('Try running with --verbose');
+  });
+
+  it('formats DistyllError without hint', () => {
+    const err = new DistyllError('Bad input');
+    const msg = formatError(err);
+    expect(msg).toBe('Error: Bad input');
+  });
+
+  it('formats plain Error', () => {
+    const err = new Error('generic error');
+    const msg = formatError(err);
+    expect(msg).toBe('Error: generic error');
+  });
+
+  it('formats non-Error values', () => {
+    expect(formatError('oops')).toBe('Error: oops');
+    expect(formatError(42)).toBe('Error: 42');
+  });
+});
+
+describe('special content handling', () => {
+  it('handles files with only whitespace', () => {
+    const filePath = createTempFile('   \n\n  \n', '.js');
+    const result = scanFile(filePath);
+    // Should parse without crashing — whitespace-only file is technically valid
+    expect(result).not.toBeNull();
+    expect(result!.findings).toHaveLength(0);
+  });
+
+  it('handles files with unicode content', () => {
+    const filePath = createTempFile(
+      'const greeting = "こんにちは世界";\nconsole.log(greeting);\n',
+      '.js'
+    );
+    const result = scanFile(filePath);
+    expect(result).not.toBeNull();
+  });
+
+  it('handles very long single-line files', () => {
+    const longLine = 'const x = ' + '"a".repeat(10000)' + ';\n';
+    const filePath = createTempFile(longLine, '.js');
+    const result = scanFile(filePath);
+    expect(result).not.toBeNull();
+  });
+});

package/tests/fingerprint/analyzer.test.ts

@@ -0,0 +1,131 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { analyzeCodebase } from '../../src/fingerprint/analyzer';
+
+describe('fingerprint analyzer', () => {
+  let tmpDir: string;
+
+  beforeAll(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'distyll-fp-test-'));
+
+    // Create sample JS file with known patterns
+    fs.writeFileSync(
+      path.join(tmpDir, 'sample.js'),
+      `
+import fs from 'fs';
+import path from 'path';
+
+// A simple function
+function calculateTotal(items) {
+  let total = 0;
+  for (const item of items) {
+    total += item.price;
+  }
+  return total;
+}
+
+function formatName(firstName, lastName) {
+  return firstName + ' ' + lastName;
+}
+
+const fetchData = async () => {
+  try {
+    const response = await fetch('/api/data');
+    return response.json();
+  } catch (err) {
+    console.error(err);
+    throw err;
+  }
+};
+
+class UserService {
+  getUser(id) {
+    return this.db.find(id);
+  }
+}
+`.trim(),
+      'utf-8'
+    );
+
+    // Create sample Python file
+    fs.writeFileSync(
+      path.join(tmpDir, 'sample.py'),
+      `
+import os
+import json
+
+def calculate_total(items):
+    total = 0
+    for item in items:
+        total += item["price"]
+    return total
+
+def format_name(first_name, last_name):
+    return first_name + " " + last_name
+`.trim(),
+      'utf-8'
+    );
+  });
+
+  afterAll(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('produces a valid style profile', async () => {
+    const profile = await analyzeCodebase([tmpDir]);
+
+    expect(profile.fileCount).toBe(2);
+    expect(profile.totalLoc).toBeGreaterThan(0);
+    expect(profile.generatedAt).toBeTruthy();
+    expect(profile.metrics).toBeDefined();
+  });
+
+  it('computes function length metrics', async () => {
+    const profile = await analyzeCodebase([tmpDir]);
+
+    expect(profile.metrics.medianFunctionLength).toBeGreaterThan(0);
+    expect(profile.metrics.averageFunctionLength).toBeGreaterThan(0);
+    expect(profile.metrics.maxFunctionLength).toBeGreaterThan(0);
+  });
+
+  it('detects naming conventions', async () => {
+    const profile = await analyzeCodebase([tmpDir]);
+    const nc = profile.metrics.namingConventions;
+
+    // Should detect some camelCase (JS) and some snake_case (Python)
+    expect(nc.camelCase + nc.snake_case + nc.PascalCase + nc.other).toBeGreaterThan(0);
+  });
+
+  it('computes comment-to-code ratio', async () => {
+    const profile = await analyzeCodebase([tmpDir]);
+
+    // We have a few comments so ratio should be > 0
+    expect(profile.metrics.commentToCodeRatio).toBeGreaterThanOrEqual(0);
+  });
+
+  it('detects try-catch usage', async () => {
+    const profile = await analyzeCodebase([tmpDir]);
+
+    // We have one try-catch in the sample
+    expect(profile.metrics.tryCatchDensity).toBeGreaterThan(0);
+  });
+
+  it('computes import metrics', async () => {
+    const profile = await analyzeCodebase([tmpDir]);
+
+    expect(profile.metrics.averageImportsPerFile).toBeGreaterThan(0);
+  });
+
+  it('handles empty directory', async () => {
+    const emptyDir = fs.mkdtempSync(path.join(os.tmpdir(), 'distyll-empty-'));
+    const profile = await analyzeCodebase([emptyDir]);
+
+    expect(profile.fileCount).toBe(0);
+    expect(profile.totalLoc).toBe(0);
+    expect(profile.metrics.medianFunctionLength).toBe(0);
+
+    fs.rmSync(emptyDir, { recursive: true, force: true });
+  });
+});

package/tests/fixes/unnecessary-try-catch.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect } from 'vitest';
+import { parse } from '../../src/parser';
+import { fixUnnecessaryTryCatch } from '../../src/fixes/unnecessary-try-catch';
+import { unnecessaryTryCatch } from '../../src/rules/unnecessary-try-catch';
+import { attachFixes } from '../../src/fixes';
+
+describe('fix: unnecessary-try-catch', () => {
+  it('generates a fix that unwraps the try body', () => {
+    const code = `try {
+  const x = 1;
+  const y = 2;
+} catch (e) {
+  console.log(e);
+}`;
+    const tree = parse(code, 'javascript');
+
+    const fix = fixUnnecessaryTryCatch(tree, code, 1);
+    expect(fix).not.toBeNull();
+    expect(fix!.description).toContain('Remove try-catch');
+    expect(fix!.replacement).toContain('const x = 1');
+    expect(fix!.replacement).toContain('const y = 2');
+    // Should not contain catch block
+    expect(fix!.replacement).not.toContain('catch');
+  });
+
+  it('returns null for lines without try-catch', () => {
+    const code = `const x = 1;`;
+    const tree = parse(code, 'javascript');
+
+    const fix = fixUnnecessaryTryCatch(tree, code, 1);
+    expect(fix).toBeNull();
+  });
+
+  it('attaches fix to findings via attachFixes', () => {
+    const code = `try {
+  const x = 1;
+  const y = 2;
+} catch (e) {
+  console.log(e);
+}`;
+    const tree = parse(code, 'javascript');
+    const findings = unnecessaryTryCatch.check(tree, code, 'test.js');
+    expect(findings.length).toBeGreaterThan(0);
+
+    const withFixes = attachFixes(findings, tree, code);
+    expect(withFixes[0].fix).toBeDefined();
+    expect(withFixes[0].fix!.description).toContain('Remove try-catch');
+  });
+
+  it('generates fix for rethrow-only catch', () => {
+    const code = `try {
+  doSomething();
+} catch (e) {
+  throw e;
+}`;
+    const tree = parse(code, 'javascript');
+
+    const fix = fixUnnecessaryTryCatch(tree, code, 1);
+    expect(fix).not.toBeNull();
+    expect(fix!.replacement).toContain('doSomething()');
+  });
+});

package/tests/git.test.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect } from 'vitest';
+import { parseDiff } from '../src/git';
+
+describe('parseDiff', () => {
+  it('should parse a simple diff with one file', () => {
+    const diff = `diff --git a/test.js b/test.js
+index 1234567..abcdefg 100644
+--- a/test.js
++++ b/test.js
+@@ -1,3 +1,5 @@
+ const x = 1;
++const y = 2;
++const z = 3;
+ const a = 4;
+`;
+    const hunks = parseDiff(diff, '/repo');
+    expect(hunks).toHaveLength(1);
+    expect(hunks[0].file).toBe('/repo/test.js');
+    expect(hunks[0].addedLines).toEqual([1, 2, 3, 4, 5]);
+  });
+
+  it('should parse a diff with multiple files', () => {
+    const diff = `diff --git a/foo.js b/foo.js
+index 1234567..abcdefg 100644
+--- a/foo.js
++++ b/foo.js
+@@ -0,0 +1,3 @@
++line 1
++line 2
++line 3
+diff --git a/bar.js b/bar.js
+index 1234567..abcdefg 100644
+--- a/bar.js
++++ b/bar.js
+@@ -5,0 +6,2 @@
++new line 1
++new line 2
+`;
+    const hunks = parseDiff(diff, '/repo');
+    expect(hunks).toHaveLength(2);
+    expect(hunks[0].file).toBe('/repo/foo.js');
+    expect(hunks[0].addedLines).toEqual([1, 2, 3]);
+    expect(hunks[1].file).toBe('/repo/bar.js');
+    expect(hunks[1].addedLines).toEqual([6, 7]);
+  });
+
+  it('should handle empty diff', () => {
+    const hunks = parseDiff('', '/repo');
+    expect(hunks).toHaveLength(0);
+  });
+
+  it('should parse a diff with multiple hunks in one file', () => {
+    const diff = `diff --git a/test.js b/test.js
+index 1234567..abcdefg 100644
+--- a/test.js
++++ b/test.js
+@@ -1,0 +2,1 @@
++new line at top
+@@ -10,0 +12,2 @@
++new line in middle 1
++new line in middle 2
+`;
+    const hunks = parseDiff(diff, '/repo');
+    expect(hunks).toHaveLength(1);
+    expect(hunks[0].addedLines).toEqual([2, 12, 13]);
+  });
+
+  it('should handle single-line hunk with no count', () => {
+    const diff = `diff --git a/test.js b/test.js
+--- a/test.js
++++ b/test.js
+@@ -5 +5 @@
++replaced line
+`;
+    const hunks = parseDiff(diff, '/repo');
+    expect(hunks).toHaveLength(1);
+    expect(hunks[0].addedLines).toEqual([5]);
+  });
+});

package/tests/rules/hallucinated-imports.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { hallucinatedImports } from '../../src/rules/hallucinated-imports';
+import { parse } from '../../src/parser';
+
+function checkJS(code: string, filePath?: string) {
+  const tree = parse(code, 'javascript');
+  return hallucinatedImports.check(tree, code, filePath ?? '/tmp/test.js');
+}
+
+function checkPython(code: string, filePath?: string) {
+  const tree = parse(code, 'python');
+  return hallucinatedImports.check(tree, code, filePath ?? '/tmp/test.py');
+}
+
+describe('hallucinated-imports', () => {
+  it('flags a relative import that does not exist', () => {
+    const findings = checkJS(`import { foo } from './nonexistent';`);
+    expect(findings.length).toBeGreaterThan(0);
+    expect(findings[0].message).toContain('nonexistent');
+  });
+
+  it('does NOT flag Node.js stdlib imports', () => {
+    const findings = checkJS(`import * as fs from 'fs';`);
+    expect(findings).toHaveLength(0);
+  });
+
+  it('does NOT flag node: protocol imports', () => {
+    const findings = checkJS(`import { readFile } from 'node:fs';`);
+    expect(findings).toHaveLength(0);
+  });
+
+  it('does NOT flag Python stdlib imports', () => {
+    const findings = checkPython(`import os\nimport sys\nimport json`);
+    expect(findings).toHaveLength(0);
+  });
+
+  it('does NOT flag Python from-imports of stdlib', () => {
+    const findings = checkPython(`from pathlib import Path`);
+    expect(findings).toHaveLength(0);
+  });
+
+  it('does NOT flag installed node_modules', () => {
+    // Use a known installed package in this project
+    const projFile = path.join(process.cwd(), 'src', 'test.js');
+    const findings = checkJS(`import chalk from 'chalk';`, projFile);
+    expect(findings).toHaveLength(0);
+  });
+
+  it('flags relative import to missing file', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'distyll-test-'));
+    const testFile = path.join(tmpDir, 'index.js');
+    fs.writeFileSync(testFile, '');
+    const findings = checkJS(`import { bar } from './missing-module';`, testFile);
+    expect(findings.length).toBeGreaterThan(0);
+  });
+});