thanh-kit 2.5.0 → 2.5.2

package/templates/hooks/tests/scout-block/path-extractor.test.cjs

@@ -0,0 +1,527 @@
+#!/usr/bin/env node
+/**
+ * path-extractor.test.cjs - Exhaustive unit tests for path extraction
+ *
+ * This is the #1 bug source in scout-block. Covers:
+ * - Token classification (blocked dir vs command keyword)
+ * - Compound commands (&&, ||, ;, newlines)
+ * - Quoted paths and flag-value pairs
+ * - Real LLM output patterns (redirects, pipes, env vars)
+ * - Edge cases and regressions
+ *
+ * Run: node --test .claude/hooks/tests/scout-block/path-extractor.test.cjs
+ */
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+  extractFromToolInput,
+  extractFromCommand,
+  looksLikePath,
+  isSkippableToken,
+  isCommandKeyword,
+  isBlockedDirName,
+  normalizeExtractedPath,
+  BLOCKED_DIR_NAMES,
+  EXCLUDE_FLAGS
+} = require('../../scout-block/path-extractor.cjs');
+
+
+// ═══════════════════════════════════════════════════════════════════════════
+// extractFromToolInput — direct path params
+// ═══════════════════════════════════════════════════════════════════════════
+
+describe('extractFromToolInput', () => {
+  it('extracts file_path param', () => {
+    const paths = extractFromToolInput({ file_path: 'src/index.ts' });
+    assert.deepStrictEqual(paths, ['src/index.ts']);
+  });
+
+  it('extracts path param', () => {
+    const paths = extractFromToolInput({ path: 'node_modules' });
+    assert.deepStrictEqual(paths, ['node_modules']);
+  });
+
+  it('extracts pattern param', () => {
+    const paths = extractFromToolInput({ pattern: '**/*.ts' });
+    assert.deepStrictEqual(paths, ['**/*.ts']);
+  });
+
+  it('extracts multiple params at once', () => {
+    const paths = extractFromToolInput({ file_path: 'a.ts', path: 'src', pattern: '*.js' });
+    assert.strictEqual(paths.length, 3);
+  });
+
+  it('extracts from command field', () => {
+    const paths = extractFromToolInput({ command: 'cat node_modules/pkg/index.js' });
+    assert.ok(paths.some(p => p.includes('node_modules')));
+  });
+
+  it('returns empty for null/undefined input', () => {
+    assert.deepStrictEqual(extractFromToolInput(null), []);
+    assert.deepStrictEqual(extractFromToolInput(undefined), []);
+    assert.deepStrictEqual(extractFromToolInput({}), []);
+  });
+
+  it('returns empty for non-object input', () => {
+    assert.deepStrictEqual(extractFromToolInput('string'), []);
+    assert.deepStrictEqual(extractFromToolInput(42), []);
+  });
+
+  it('ignores non-string param values', () => {
+    assert.deepStrictEqual(extractFromToolInput({ file_path: 123 }), []);
+    assert.deepStrictEqual(extractFromToolInput({ path: null }), []);
+  });
+});
+
+
+// ═══════════════════════════════════════════════════════════════════════════
+// extractFromCommand — token extraction from bash commands
+// ═══════════════════════════════════════════════════════════════════════════
+
+describe('extractFromCommand', () => {
+
+  // --- Blocked directory names ---
+  describe('blocked directory extraction', () => {
+    it('extracts "node_modules" as blocked dir', () => {
+      const paths = extractFromCommand('ls node_modules');
+      assert.ok(paths.includes('node_modules'));
+    });
+
+    it('extracts "build" as blocked dir after cd', () => {
+      const paths = extractFromCommand('cd build');
+      assert.ok(paths.includes('build'));
+    });
+
+    it('extracts "dist" as blocked dir', () => {
+      const paths = extractFromCommand('ls dist');
+      assert.ok(paths.includes('dist'));
+    });
+
+    it('extracts ".venv" as blocked dir', () => {
+      const paths = extractFromCommand('ls .venv');
+      assert.ok(paths.includes('.venv'));
+    });
+
+    it('extracts "venv" as blocked dir', () => {
+      const paths = extractFromCommand('ls venv');
+      assert.ok(paths.includes('venv'));
+    });
+
+    it('extracts "__pycache__" as blocked dir', () => {
+      const paths = extractFromCommand('ls __pycache__');
+      assert.ok(paths.includes('__pycache__'));
+    });
+
+    it('extracts ".git" as blocked dir', () => {
+      const paths = extractFromCommand('ls .git');
+      assert.ok(paths.includes('.git'));
+    });
+
+    it('extracts "coverage" as blocked dir', () => {
+      const paths = extractFromCommand('ls coverage');
+      assert.ok(paths.includes('coverage'));
+    });
+
+    it('extracts "target" as blocked dir', () => {
+      const paths = extractFromCommand('ls target');
+      assert.ok(paths.includes('target'));
+    });
+
+    it('extracts "vendor" as blocked dir', () => {
+      const paths = extractFromCommand('ls vendor');
+      assert.ok(paths.includes('vendor'));
+    });
+  });
+
+  // --- Nested/path-like tokens ---
+  describe('nested path extraction', () => {
+    it('extracts nested node_modules path', () => {
+      const paths = extractFromCommand('ls packages/web/node_modules');
+      assert.ok(paths.some(p => p.includes('node_modules')));
+    });
+
+    it('extracts dist/bundle.js', () => {
+      const paths = extractFromCommand('cat dist/bundle.js');
+      assert.ok(paths.some(p => p.includes('dist')));
+    });
+
+    it('extracts .venv/lib/python3.11', () => {
+      const paths = extractFromCommand('cat .venv/lib/python3.11/site.py');
+      assert.ok(paths.some(p => p.includes('.venv')));
+    });
+
+    it('extracts path with file extension', () => {
+      const paths = extractFromCommand('cat src/index.ts');
+      assert.ok(paths.some(p => p === 'src/index.ts'));
+    });
+  });
+
+  // --- Command keywords should NOT be extracted ---
+  describe('command keyword filtering', () => {
+    it('does not extract bare command keywords', () => {
+      // These are commands/subcommands, not paths
+      const keywords = ['echo', 'cat', 'ls', 'cd', 'npm', 'git', 'docker'];
+      for (const kw of keywords) {
+        // When used as the command itself (first token), it's skipped
+        const paths = extractFromCommand(`${kw} src/file.ts`);
+        assert.ok(!paths.includes(kw), `"${kw}" should not be extracted as path`);
+      }
+    });
+
+    it('does not extract "run" as path', () => {
+      const paths = extractFromCommand('npm run src/script.js');
+      assert.ok(!paths.includes('run'));
+    });
+
+    it('does not extract "test" as path from npm command', () => {
+      const paths = extractFromCommand('npm test');
+      assert.ok(!paths.includes('test'));
+    });
+  });
+
+  // --- Quoted paths ---
+  describe('quoted path extraction', () => {
+    it('extracts double-quoted path', () => {
+      const paths = extractFromCommand('cat "src/my file.ts"');
+      assert.ok(paths.some(p => p.includes('src/my file.ts')));
+    });
+
+    it('extracts single-quoted path', () => {
+      const paths = extractFromCommand("cat 'src/my file.ts'");
+      assert.ok(paths.some(p => p.includes('src/my file.ts')));
+    });
+
+    it('extracts quoted path with blocked dir', () => {
+      const paths = extractFromCommand("cat 'node_modules/pkg/index.js'");
+      assert.ok(paths.some(p => p.includes('node_modules')));
+    });
+  });
+
+  // --- Flag-value pairs (exclude semantics) ---
+  describe('exclude flag handling', () => {
+    it('skips value after --exclude', () => {
+      const paths = extractFromCommand('grep --exclude node_modules src/');
+      assert.ok(!paths.includes('node_modules'), '--exclude value should be skipped');
+      assert.ok(paths.some(p => p.includes('src')));
+    });
+
+    it('skips value after --ignore', () => {
+      const paths = extractFromCommand('find . --ignore dist');
+      assert.ok(!paths.includes('dist'), '--ignore value should be skipped');
+    });
+
+    it('skips value after --skip', () => {
+      const paths = extractFromCommand('tool --skip node_modules src/');
+      assert.ok(!paths.includes('node_modules'));
+    });
+
+    it('skips value after -x', () => {
+      const paths = extractFromCommand('tar -x node_modules archive.tar');
+      assert.ok(!paths.includes('node_modules'));
+    });
+
+    it('skips value after --exclude-dir', () => {
+      const paths = extractFromCommand('grep --exclude-dir node_modules pattern src/');
+      assert.ok(!paths.includes('node_modules'));
+    });
+  });
+
+  // --- Flags and shell operators ---
+  describe('skippable tokens', () => {
+    it('skips flags', () => {
+      const paths = extractFromCommand('ls -la src/');
+      assert.ok(!paths.includes('-la'));
+    });
+
+    it('skips shell pipe operator', () => {
+      const paths = extractFromCommand('cat src/file.ts | head');
+      assert.ok(!paths.some(p => p === '|'));
+    });
+
+    it('skips redirect operators', () => {
+      const paths = extractFromCommand('echo test > output.txt');
+      assert.ok(!paths.some(p => p === '>'));
+    });
+
+    it('skips numeric values', () => {
+      const paths = extractFromCommand('head -n 100 src/file.ts');
+      assert.ok(!paths.includes('100'));
+    });
+  });
+
+  // --- Real LLM output patterns ---
+  describe('real LLM output patterns', () => {
+    it('handles npm run build with redirect and pipe', () => {
+      const paths = extractFromCommand('npm run build 2>&1 | tail -15');
+      // Should NOT extract blocked paths — this is a build command context
+      // (Note: path-extractor alone doesn't know about build allowlists,
+      //  but it should not extract "build" since it's a command keyword)
+      // "build" IS extracted as blocked dir name (isBlockedDirName priority)
+      // This is expected — scout-checker handles the allowlist at a higher level
+    });
+
+    it('handles cd to absolute path', () => {
+      const paths = extractFromCommand('cd /Users/kai/project');
+      assert.ok(paths.some(p => p.includes('/Users/kai/project')));
+    });
+
+    it('handles env var prefix before command', () => {
+      // NODE_ENV=production is not a path
+      const paths = extractFromCommand('NODE_ENV=production npm run build');
+      assert.ok(!paths.some(p => p === 'NODE_ENV=production'));
+    });
+
+    it('handles multiple files in one command', () => {
+      const paths = extractFromCommand('cat src/a.ts src/b.ts');
+      assert.ok(paths.some(p => p === 'src/a.ts'));
+      assert.ok(paths.some(p => p === 'src/b.ts'));
+    });
+
+    it('handles relative path ./src/file.ts', () => {
+      const paths = extractFromCommand('cat ./src/file.ts');
+      assert.ok(paths.some(p => p.includes('src/file.ts')));
+    });
+
+    it('handles parent path ../other/file.ts', () => {
+      const paths = extractFromCommand('cat ../other/file.ts');
+      assert.ok(paths.some(p => p.includes('../other/file.ts')));
+    });
+
+    it('handles git commands with paths', () => {
+      const paths = extractFromCommand('git diff src/index.ts');
+      assert.ok(paths.some(p => p === 'src/index.ts'));
+    });
+
+    it('handles chmod on a file', () => {
+      const paths = extractFromCommand('chmod +x scripts/deploy.sh');
+      assert.ok(paths.some(p => p === 'scripts/deploy.sh'));
+    });
+
+    it('handles mkdir -p with path', () => {
+      const paths = extractFromCommand('mkdir -p src/components/auth');
+      assert.ok(paths.some(p => p.includes('src/components/auth')));
+    });
+  });
+
+  // --- Edge cases ---
+  describe('edge cases', () => {
+    it('returns empty for null command', () => {
+      assert.deepStrictEqual(extractFromCommand(null), []);
+    });
+
+    it('returns empty for empty string', () => {
+      assert.deepStrictEqual(extractFromCommand(''), []);
+    });
+
+    it('returns empty for whitespace-only', () => {
+      assert.deepStrictEqual(extractFromCommand('   '), []);
+    });
+
+    it('handles command with no path-like tokens', () => {
+      const paths = extractFromCommand('echo hello world');
+      // "hello" and "world" don't look like paths
+      assert.ok(!paths.some(p => p === 'hello'));
+      assert.ok(!paths.some(p => p === 'world'));
+    });
+
+    it('handles single-token command', () => {
+      const paths = extractFromCommand('pwd');
+      assert.deepStrictEqual(paths, []);
+    });
+
+    it('handles very long command', () => {
+      const longPath = 'src/' + 'a/'.repeat(50) + 'file.ts';
+      const paths = extractFromCommand(`cat ${longPath}`);
+      assert.ok(paths.length > 0);
+    });
+  });
+});
+
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Helper functions — unit tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+describe('looksLikePath', () => {
+  it('returns true for paths with /', () => {
+    assert.ok(looksLikePath('src/index.ts'));
+  });
+
+  it('returns true for paths with backslash', () => {
+    assert.ok(looksLikePath('src\\index.ts'));
+  });
+
+  it('returns true for relative paths', () => {
+    assert.ok(looksLikePath('./src/file.ts'));
+    assert.ok(looksLikePath('../other/file.ts'));
+  });
+
+  it('returns true for file extensions', () => {
+    assert.ok(looksLikePath('file.ts'));
+    assert.ok(looksLikePath('app.py'));
+    assert.ok(looksLikePath('Makefile.toml'));
+  });
+
+  it('returns false for bare blocked dir names (no path structure)', () => {
+    // Bare names without / or extension are NOT path-like.
+    // They get caught by isBlockedDirName in filesystem command context instead.
+    assert.ok(!looksLikePath('node_modules'));
+    assert.ok(!looksLikePath('dist'));
+    assert.ok(!looksLikePath('build'));
+  });
+
+  it('returns true for blocked dir names WITH path structure', () => {
+    assert.ok(looksLikePath('node_modules/pkg'));
+    assert.ok(looksLikePath('dist/bundle.js'));
+    assert.ok(looksLikePath('build/output'));
+  });
+
+  it('returns true for directory-like paths', () => {
+    assert.ok(looksLikePath('src/components'));
+  });
+
+  it('returns false for short strings', () => {
+    assert.ok(!looksLikePath('a'));
+    assert.ok(!looksLikePath(''));
+  });
+
+  it('returns false for null/undefined', () => {
+    assert.ok(!looksLikePath(null));
+    assert.ok(!looksLikePath(undefined));
+  });
+
+  it('returns false for plain words without path indicators', () => {
+    assert.ok(!looksLikePath('hello'));
+    assert.ok(!looksLikePath('world'));
+  });
+});
+
+describe('isSkippableToken', () => {
+  it('skips flags starting with -', () => {
+    assert.ok(isSkippableToken('-la'));
+    assert.ok(isSkippableToken('--verbose'));
+    assert.ok(isSkippableToken('-n'));
+  });
+
+  it('skips shell operators', () => {
+    assert.ok(isSkippableToken('|'));
+    assert.ok(isSkippableToken('||'));
+    assert.ok(isSkippableToken('&&'));
+    assert.ok(isSkippableToken('>'));
+    assert.ok(isSkippableToken('>>'));
+    assert.ok(isSkippableToken('<'));
+    assert.ok(isSkippableToken(';'));
+    assert.ok(isSkippableToken('&'));
+  });
+
+  it('skips numeric values', () => {
+    assert.ok(isSkippableToken('100'));
+    assert.ok(isSkippableToken('0'));
+  });
+
+  it('does not skip normal words', () => {
+    assert.ok(!isSkippableToken('src'));
+    assert.ok(!isSkippableToken('file.ts'));
+    assert.ok(!isSkippableToken('node_modules'));
+  });
+});
+
+describe('isCommandKeyword', () => {
+  it('recognizes shell commands', () => {
+    const commands = ['echo', 'cat', 'ls', 'cd', 'rm', 'cp', 'mv', 'find', 'grep'];
+    for (const cmd of commands) {
+      assert.ok(isCommandKeyword(cmd), `"${cmd}" should be a keyword`);
+    }
+  });
+
+  it('recognizes package manager commands', () => {
+    const cmds = ['npm', 'pnpm', 'yarn', 'bun', 'npx'];
+    for (const cmd of cmds) {
+      assert.ok(isCommandKeyword(cmd), `"${cmd}" should be a keyword`);
+    }
+  });
+
+  it('recognizes package manager subcommands', () => {
+    const subs = ['run', 'build', 'test', 'lint', 'dev', 'start', 'install'];
+    for (const sub of subs) {
+      assert.ok(isCommandKeyword(sub), `"${sub}" should be a keyword`);
+    }
+  });
+
+  it('recognizes git subcommands', () => {
+    const subs = ['commit', 'push', 'pull', 'merge', 'checkout', 'branch'];
+    for (const sub of subs) {
+      assert.ok(isCommandKeyword(sub), `"${sub}" should be a keyword`);
+    }
+  });
+
+  it('recognizes build tools', () => {
+    const tools = ['tsc', 'esbuild', 'vite', 'webpack', 'jest', 'vitest'];
+    for (const tool of tools) {
+      assert.ok(isCommandKeyword(tool), `"${tool}" should be a keyword`);
+    }
+  });
+
+  it('is case-insensitive', () => {
+    assert.ok(isCommandKeyword('NPM'));
+    assert.ok(isCommandKeyword('Git'));
+  });
+
+  it('does not match paths', () => {
+    assert.ok(!isCommandKeyword('src/file.ts'));
+    assert.ok(!isCommandKeyword('my-package'));
+  });
+});
+
+describe('isBlockedDirName', () => {
+  it('matches all BLOCKED_DIR_NAMES', () => {
+    for (const name of BLOCKED_DIR_NAMES) {
+      assert.ok(isBlockedDirName(name), `"${name}" should be blocked`);
+    }
+  });
+
+  it('does not match non-blocked names', () => {
+    assert.ok(!isBlockedDirName('src'));
+    assert.ok(!isBlockedDirName('lib'));
+    assert.ok(!isBlockedDirName('app'));
+    assert.ok(!isBlockedDirName('hello'));
+  });
+
+  it('does not match partial/path names', () => {
+    assert.ok(!isBlockedDirName('node_modules/pkg'));
+    assert.ok(!isBlockedDirName('my-dist'));
+  });
+});
+
+describe('normalizeExtractedPath', () => {
+  it('trims whitespace', () => {
+    assert.strictEqual(normalizeExtractedPath('  src/file.ts  '), 'src/file.ts');
+  });
+
+  it('removes surrounding double quotes', () => {
+    assert.strictEqual(normalizeExtractedPath('"src/file.ts"'), 'src/file.ts');
+  });
+
+  it('removes surrounding single quotes', () => {
+    assert.strictEqual(normalizeExtractedPath("'src/file.ts'"), 'src/file.ts');
+  });
+
+  it('normalizes backslashes to forward slashes', () => {
+    assert.strictEqual(normalizeExtractedPath('src\\file.ts'), 'src/file.ts');
+  });
+
+  it('removes trailing slash', () => {
+    assert.strictEqual(normalizeExtractedPath('src/'), 'src');
+  });
+
+  it('keeps root slash', () => {
+    assert.strictEqual(normalizeExtractedPath('/'), '/');
+  });
+
+  it('returns empty for null/undefined', () => {
+    assert.strictEqual(normalizeExtractedPath(null), '');
+    assert.strictEqual(normalizeExtractedPath(undefined), '');
+  });
+});