distyll 0.1.0

package/tests/rules/near-duplicate-functions.test.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect } from 'vitest';
+import { nearDuplicateFunctions } from '../../src/rules/near-duplicate-functions';
+import { parse } from '../../src/parser';
+
+function checkJS(code: string) {
+  const tree = parse(code, 'javascript');
+  return nearDuplicateFunctions.check(tree, code, 'test.js');
+}
+
+function checkPython(code: string) {
+  const tree = parse(code, 'python');
+  return nearDuplicateFunctions.check(tree, code, 'test.py');
+}
+
+describe('near-duplicate-functions', () => {
+  it('flags near-duplicate JS functions', () => {
+    const code = `
+function processUserData(user) {
+  const result = {};
+  result.name = user.name.trim().toLowerCase();
+  result.email = user.email.trim().toLowerCase();
+  result.age = parseInt(user.age, 10);
+  result.active = Boolean(user.active);
+  return result;
+}
+
+function processAdminData(admin) {
+  const result = {};
+  result.name = admin.name.trim().toLowerCase();
+  result.email = admin.email.trim().toLowerCase();
+  result.age = parseInt(admin.age, 10);
+  result.active = Boolean(admin.active);
+  return result;
+}
+`;
+    const findings = checkJS(code);
+    expect(findings.length).toBeGreaterThan(0);
+    expect(findings[0].message).toContain('similar');
+  });
+
+  it('does NOT flag functions with different logic', () => {
+    const code = `
+function add(a, b) {
+  const result = a + b;
+  console.log('Adding:', a, b);
+  return result;
+}
+
+function multiply(a, b) {
+  const result = a * b;
+  console.log('Multiplying:', a, b);
+  return Math.floor(result);
+}
+`;
+    const findings = checkJS(code);
+    expect(findings).toHaveLength(0);
+  });
+
+  it('ignores short functions', () => {
+    const code = `
+function a() { return 1; }
+function b() { return 1; }
+`;
+    const findings = checkJS(code);
+    expect(findings).toHaveLength(0);
+  });
+
+  it('flags near-duplicate Python functions', () => {
+    const code = `
+def process_user_data(user):
+    result = {}
+    result['name'] = user['name'].strip().lower()
+    result['email'] = user['email'].strip().lower()
+    result['age'] = int(user['age'])
+    result['active'] = bool(user['active'])
+    return result
+
+def process_admin_data(admin):
+    result = {}
+    result['name'] = admin['name'].strip().lower()
+    result['email'] = admin['email'].strip().lower()
+    result['age'] = int(admin['age'])
+    result['active'] = bool(admin['active'])
+    return result
+`;
+    const findings = checkPython(code);
+    expect(findings.length).toBeGreaterThan(0);
+    expect(findings[0].message).toContain('similar');
+  });
+});

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

@@ -0,0 +1,81 @@
+import { describe, it, expect } from 'vitest';
+import { unnecessaryTryCatch } from '../../src/rules/unnecessary-try-catch';
+import { parse } from '../../src/parser';
+
+function check(code: string, lang: 'javascript' | 'typescript' = 'javascript') {
+  const tree = parse(code, lang);
+  return unnecessaryTryCatch.check(tree, code, 'test.js');
+}
+
+describe('unnecessary-try-catch', () => {
+  it('flags try-catch that only rethrows', () => {
+    const findings = check(`
+try {
+  doSomething();
+} catch (e) {
+  throw e;
+}
+`);
+    expect(findings).toHaveLength(1);
+    expect(findings[0].message).toContain('rethrow');
+  });
+
+  it('flags try-catch around pure assignments', () => {
+    const findings = check(`
+try {
+  const x = 1;
+  const y = 2;
+} catch (e) {
+  console.log(e);
+}
+`);
+    expect(findings).toHaveLength(1);
+    expect(findings[0].message).toContain('unlikely to throw');
+  });
+
+  it('does NOT flag try-catch around function calls', () => {
+    const findings = check(`
+try {
+  const data = JSON.parse(input);
+} catch (e) {
+  console.log('Parse error:', e);
+}
+`);
+    expect(findings).toHaveLength(0);
+  });
+
+  it('does NOT flag try-catch around await', () => {
+    const findings = check(`
+async function load() {
+  try {
+    const data = await fetchData();
+  } catch (e) {
+    handleError(e);
+  }
+}
+`);
+    expect(findings).toHaveLength(0);
+  });
+
+  it('does NOT flag try-catch around property access', () => {
+    const findings = check(`
+try {
+  const name = obj.deeply.nested.property;
+} catch (e) {
+  console.log('Access error:', e);
+}
+`);
+    expect(findings).toHaveLength(0);
+  });
+
+  it('does NOT flag try-catch that contains throw', () => {
+    const findings = check(`
+try {
+  if (!valid) throw new Error('invalid');
+} catch (e) {
+  log(e);
+}
+`);
+    expect(findings).toHaveLength(0);
+  });
+});

package/tests/scanner.test.ts

@@ -0,0 +1,88 @@
+import { describe, it, expect } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { scanPaths, scanFile } from '../src/scanner';
+
+function createTempFile(content: string, ext: string = '.js'): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'distyll-test-'));
+  const filePath = path.join(dir, `test${ext}`);
+  fs.writeFileSync(filePath, content);
+  return filePath;
+}
+
+describe('scanFile', () => {
+  it('returns null for unsupported file types', () => {
+    const filePath = createTempFile('hello world', '.txt');
+    expect(scanFile(filePath)).toBeNull();
+  });
+
+  it('returns null for empty files', () => {
+    const filePath = createTempFile('', '.js');
+    expect(scanFile(filePath)).toBeNull();
+  });
+
+  it('scans a clean JS file with no findings', () => {
+    const filePath = createTempFile(`
+function add(a, b) {
+  return a + b;
+}
+
+const result = add(1, 2);
+console.log(result);
+`, '.js');
+    const result = scanFile(filePath);
+    expect(result).not.toBeNull();
+    expect(result!.findings).toHaveLength(0);
+  });
+
+  it('detects a single-use wrapper function', () => {
+    const filePath = createTempFile(`
+function wrapper(x) {
+  return doThing(x);
+}
+`, '.js');
+    const result = scanFile(filePath);
+    expect(result).not.toBeNull();
+    const wrapperFindings = result!.findings.filter(f => f.rule === 'single-use-wrapper');
+    expect(wrapperFindings.length).toBeGreaterThan(0);
+  });
+
+  it('scans TypeScript files', () => {
+    const filePath = createTempFile(`
+interface Options {
+  name: string;
+}
+
+function greet(options: Options): string {
+  return 'Hello ' + options.name;
+}
+`, '.ts');
+    const result = scanFile(filePath);
+    expect(result).not.toBeNull();
+    expect(result!.loc).toBeGreaterThan(0);
+  });
+});
+
+describe('scanPaths', () => {
+  it('scans a directory of files', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'distyll-test-'));
+    fs.writeFileSync(path.join(dir, 'a.js'), 'const x = 1;\n');
+    fs.writeFileSync(path.join(dir, 'b.ts'), 'const y: number = 2;\n');
+    fs.writeFileSync(path.join(dir, 'c.txt'), 'not scanned');
+
+    const summary = await scanPaths([dir]);
+    expect(summary.results.length).toBe(2);
+    expect(summary.score).toBeGreaterThanOrEqual(0);
+  });
+
+  it('returns score of 0 for clean code', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'distyll-test-'));
+    fs.writeFileSync(
+      path.join(dir, 'clean.js'),
+      `function add(a, b) {\n  return a + b;\n}\n`
+    );
+    const summary = await scanPaths([dir]);
+    expect(summary.score).toBe(0);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "lib": ["ES2022"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests", "site"]
+}

package/twitter_thread.md

@@ -0,0 +1,46 @@
+1/ AI coding tools write code that "works" but is quietly bloating your codebase.
+
+Unnecessary try-catch blocks. Single-use abstractions. Comments restating the obvious. Imports that go nowhere.
+
+I built a tool to catch it automatically.
+
+2/ The problem: linters check syntax. Formatters check style. But NOTHING catches the structural anti-patterns unique to AI-generated code.
+
+Your codebase is accumulating "slop" and code review isn't catching it fast enough.
+
+3/ Meet Distyll — a CLI that scans JS/TS/Python for 12 AI code anti-patterns using AST analysis (tree-sitter).
+
+No LLM needed. Runs in seconds. Assigns a slop score from 0-100 with specific fix suggestions.
+
+4/ What it catches:
+
+- Try-catch wrapping pure synchronous functions
+- Single-use wrapper abstractions
+- Verbose comments restating code
+- Hallucinated/unused imports
+- Near-duplicate functions (>85% similarity)
+- Dead code paths
+- Over-engineered options objects
+
+5/ Multiple ways to run it:
+
+`distyll scan .` — full project scan
+`distyll diff` — only changed lines
+`distyll hook install` — pre-commit gate
+`distyll ci` — GitHub Actions with annotations
+
+6/ The `fingerprint` command profiles YOUR codebase's patterns — naming conventions, abstraction style, comment density.
+
+Then it flags AI-generated code that doesn't match your team's conventions. Not generic rules. YOUR rules.
+
+7/ I ran it on my own repos that used Cursor and Claude Code heavily.
+
+Found dozens of pointless abstractions and defensive code blocks I'd approved in review without thinking twice.
+
+The "comfortable drift" is real.
+
+8/ Distyll is open source and free to use.
+
+[GITHUB_URL]
+
+Try it on your AI-assisted codebase. The slop score might surprise you.

package/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['tests/**/*.test.ts'],
+  },
+});