@0xcraft/powershot 1.1.3 → 1.1.4

package/README.md

@@ -123,7 +123,7 @@ oracle is never counted as a pass in either profile.
 | `phantom-dep` | Imports absent from project manifests | Dependency manifests |
 | `phantom-config` | Configuration keys with no declared source | Repository config index |
 | `contract-drift` | Signature changes with callers left behind | Types and references |
-| `reinvented` | New helpers duplicating existing symbols | Symbol index |
+| `reinvented` | New callables that exactly repeat an implementation already present in the same package | Base symbol + token fingerprint |
 | `dropped-guard` | Removed guards, early returns, protective branches | Pre/post AST |
 | `swallowed-error` | Empty or ineffective error handling | AST shape |
 | `vacuous-test` | Tests that do not assert behavior | Test AST |

package/dist/ground.js

@@ -4,6 +4,7 @@ import { decode } from './text.js';
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { PACKS, packFor, parseIsolated } from './lang/packs.js';
 import { insideRepo, isSymlink, repoPath } from './fspolicy.js';
+import { createReinventionScopeResolver, typescriptImplementationFingerprint } from './reinvention.js';
 const CODE_EXT = /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/;
 const TS_CONFIG = /^tsconfig(?:\..+)?\.json$/i;
 const MISSING_TYPE_PREFIXES = [
@@ -289,7 +290,7 @@ export async function buildGround(root, changed, signal) {
         beforeProject,
         changed,
         files,
-        symbolIndex: buildSymbolIndex(sourceFiles, root),
+        symbolIndex: buildSymbolIndex(sourceFiles, root, changed, beforeProject),
         deps: depsFor(join(root, 'x.ts')),
         depsFor,
         typed,
@@ -437,8 +438,27 @@ async function parseForeign(root, changed, signal) {
         return result ? [result] : [];
     });
 }
-function buildSymbolIndex(sourceFiles, root) {
+function buildSymbolIndex(sourceFiles, root, changed, beforeProject) {
     const index = new Map();
+    const changes = new Map(changed.map((file) => [file.path, file]));
+    const scopeFor = createReinventionScopeResolver(root);
+    const relevantNames = new Set();
+    for (const sf of sourceFiles) {
+        const rel = repoPath(root, String(sf.getFilePath()));
+        if (!changes.has(rel))
+            continue;
+        for (const declaration of sf.getFunctions()) {
+            const name = declaration.getName();
+            if (name)
+                relevantNames.add(normalizeName(name));
+        }
+        for (const declaration of sf.getVariableDeclarations()) {
+            const initializer = declaration.getInitializer();
+            if (initializer?.isKind(SyntaxKind.ArrowFunction) || initializer?.isKind(SyntaxKind.FunctionExpression)) {
+                relevantNames.add(normalizeName(declaration.getName()));
+            }
+        }
+    }
     for (const sf of sourceFiles) {
         const path = String(sf.getFilePath());
         // the project glob follows symlinked directories, so what it loaded is not
@@ -446,26 +466,47 @@ function buildSymbolIndex(sourceFiles, root) {
         if (path.includes('/node_modules/') || !insideRepo(root, path))
             continue;
         for (const [name, decls] of sf.getExportedDeclarations()) {
+            const key = normalizeName(name);
+            // Fingerprint only names the change could have introduced. This keeps index
+            // construction proportional to the diff even when the project closure is a
+            // very large monorepo.
+            if (!relevantNames.has(key))
+                continue;
             const decl = decls[0];
             if (!decl)
                 continue;
             // only index things that could plausibly be reimplemented
             const kind = decl.getKind();
             if (kind !== SyntaxKind.FunctionDeclaration &&
-                kind !== SyntaxKind.VariableDeclaration &&
-                kind !== SyntaxKind.ClassDeclaration)
+                kind !== SyntaxKind.VariableDeclaration)
+                continue;
+            const fingerprint = typescriptImplementationFingerprint(decl);
+            if (!fingerprint)
+                continue;
+            // A barrel alias can be new in this change even when its underlying callable
+            // predates it. Index the declaration from its own module, where both its name
+            // and base existence can be proved, rather than manufacturing history for the
+            // new alias or recording every `export *` as another copy.
+            if (decl.getSourceFile() !== sf)
                 continue;
-            // a barrel re-exports another module's symbol, so record where it is actually
-            // declared — otherwise `export * from './x'` makes every symbol look duplicated
             const declPath = String(decl.getSourceFile().getFilePath());
             if (declPath.includes('/node_modules/') || !insideRepo(root, declPath))
                 continue;
             const rel = repoPath(root, declPath);
-            const key = normalizeName(name);
+            const change = changes.get(rel);
+            const before = change?.before === undefined ? undefined : beforeProject.getSourceFile('/before/' + rel);
+            const existedInBase = change === undefined || (before?.getExportedDeclarations().get(name) ?? []).some((baseDeclaration) => typescriptImplementationFingerprint(baseDeclaration) === fingerprint);
             const list = index.get(key) ?? [];
             if (list.some((e) => e.file === rel && e.line === decl.getStartLineNumber()))
                 continue;
-            list.push({ file: rel, name, line: decl.getStartLineNumber() });
+            list.push({
+                file: rel,
+                name,
+                line: decl.getStartLineNumber(),
+                fingerprint,
+                existedInBase,
+                scope: scopeFor(rel),
+            });
             index.set(key, list);
         }
     }

package/dist/langtest.js

@@ -8,8 +8,9 @@
  */
 import assert from 'node:assert/strict';
 import { execFileSync } from 'node:child_process';
+import { Project } from 'ts-morph';
 import { PACKS, parse } from './lang/packs.js';
-import { tokensFor } from './verifiers/foreign.js';
+import { foreignReinvented, tokensFor } from './verifiers/foreign.js';
 /** each fixture: a handler that discards, one that genuinely handles, one explained */
 const FIXTURES = {
     python: 'def f():\n    try:\n        a()\n    except Exception:\n        pass\n    try:\n        b()\n    except Exception as e:\n        raise RuntimeError("x") from e\n    try:\n        c()\n    except Exception:\n        pass  # deliberate\n',
@@ -32,6 +33,70 @@ const HANDLED = {
     rust: 'return Err(e)', cpp: 'throw;', 'c#': 'throw;', php: 'throw $e',
     kotlin: 'throw e', ruby: 'raise', solidity: 'revert("x")',
 };
+const REINVENTED_NAME = {
+    python: ['def f():', 'def normalize_payload():'],
+    go: ['func F()', 'func NormalizePayload()'],
+    java: ['class A', 'class NormalizePayload'],
+    rust: ['fn f()', 'fn normalize_payload()'],
+    cpp: ['void f()', 'void normalizePayload()'],
+    c: ['int f(', 'int normalizePayload('],
+    'c#': ['class A', 'class NormalizePayload'],
+    php: ['function f()', 'function normalizePayload()'],
+    kotlin: ['fun f()', 'fun normalizePayload()'],
+    ruby: ['def f\n', 'def normalize_payload\n'],
+    solidity: ['contract A', 'contract NormalizePayload'],
+};
+const REINVENTED_MUTATION = {
+    python: ['a()', 'z()'],
+    go: ['a()', 'z()'],
+    java: ['a()', 'z()'],
+    rust: ['a()', 'z()'],
+    cpp: ['a()', 'z()'],
+    c: ['return n;', 'return n + 1;'],
+    'c#': ['A()', 'Z()'],
+    php: ['a()', 'z()'],
+    kotlin: ['a()', 'z()'],
+    ruby: ['    a\n', '    z\n'],
+    solidity: ['a()', 'z()'],
+};
+function allLines(source) {
+    return new Set(Array.from({ length: source.split('\n').length }, (_, index) => index + 1));
+}
+async function foreignReinventionGround(pack, existingSource, addedSource, existingBeforeSource = existingSource, addedBeforeSource) {
+    const extension = pack.extensions[0];
+    const existingPath = 'z-existing' + extension;
+    const addedPath = 'a-new' + extension;
+    const existingTree = await parse(pack, existingSource);
+    const addedTree = await parse(pack, addedSource);
+    const beforeTree = existingBeforeSource === null ? undefined : await parse(pack, existingBeforeSource);
+    const addedBeforeTree = addedBeforeSource === undefined ? undefined : await parse(pack, addedBeforeSource);
+    if (!existingTree || !addedTree)
+        throw new Error('fixture did not parse');
+    const existingChange = {
+        path: existingPath,
+        added: existingBeforeSource === null ? allLines(existingSource) : new Set(),
+        before: existingBeforeSource ?? undefined,
+    };
+    const addedChange = { path: addedPath, added: allLines(addedSource), before: addedBeforeSource };
+    const foreign = [
+        { path: existingPath, pack, tree: existingTree, beforeTree, changed: existingChange },
+        { path: addedPath, pack, tree: addedTree, beforeTree: addedBeforeTree, changed: addedChange },
+    ];
+    return {
+        root: '/virtual/repo',
+        sourceFiles: [],
+        configFiles: [],
+        beforeProject: new Project({ useInMemoryFileSystem: true }),
+        changed: [existingChange, addedChange],
+        files: [],
+        symbolIndex: new Map(),
+        deps: new Set(),
+        depsFor: () => new Set(),
+        typed: false,
+        internalPrefixes: [],
+        foreign,
+    };
+}
 async function one(name) {
     const pack = PACKS.find((p) => p.name === name);
     if (!pack) {
@@ -79,6 +144,33 @@ async function one(name) {
             assert.equal(hits.some((h) => h.node.text.includes(HANDLED[name])), false, 'reported a real handler');
         });
     }
+    if (source && tree) {
+        const rename = REINVENTED_NAME[name];
+        const mutation = REINVENTED_MUTATION[name];
+        assert.ok(rename && mutation, 'no reinvention fixture written');
+        const existing = source.replace(rename[0], rename[1]);
+        const different = existing.replace(mutation[0], mutation[1]);
+        const differentGround = await foreignReinventionGround(pack, existing, different);
+        const identicalGround = await foreignReinventionGround(pack, existing, existing);
+        const bothNewGround = await foreignReinventionGround(pack, existing, existing, null);
+        const candidateChangedGround = await foreignReinventionGround(pack, existing, existing, different);
+        const targetPreexistingGround = await foreignReinventionGround(pack, existing, existing, existing, existing);
+        check('reinvented ignores a same-name different implementation', () => {
+            assert.equal(foreignReinvented.run(differentGround).length, 0);
+        });
+        check('reinvented detects an exact implementation already present in the base', () => {
+            assert.ok(foreignReinvented.run(identicalGround).length >= 1);
+        });
+        check('reinvented does not compare two declarations both added by the change', () => {
+            assert.equal(foreignReinvented.run(bothNewGround).length, 0);
+        });
+        check('reinvented ignores a candidate that only became equivalent in this change', () => {
+            assert.equal(foreignReinvented.run(candidateChangedGround).length, 0);
+        });
+        check('reinvented ignores an implementation already present in the changed file', () => {
+            assert.equal(foreignReinvented.run(targetPreexistingGround).length, 0);
+        });
+    }
     return failed;
 }
 /** Signature comparison is Python-only for now, and is what decides a contract break. */

package/dist/reinvention.js

@@ -0,0 +1,109 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readdirSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { Node, ts, } from 'ts-morph';
+import { insideRepo, repoPath } from './fspolicy.js';
+const SCOPE_FILES = [
+    'package.json',
+    'pyproject.toml', 'setup.py', 'setup.cfg',
+    'Cargo.toml', 'go.mod',
+    'pom.xml', 'build.gradle', 'build.gradle.kts', 'settings.gradle', 'settings.gradle.kts',
+    'composer.json', 'Gemfile',
+    'CMakeLists.txt', 'meson.build',
+    'foundry.toml',
+];
+const SCOPE_SUFFIX = /\.(?:csproj|sln|gemspec)$/i;
+function declaresScope(dir) {
+    if (SCOPE_FILES.some((name) => existsSync(resolve(dir, name))))
+        return true;
+    try {
+        return readdirSync(dir, { withFileTypes: true }).some((entry) => entry.isFile() && SCOPE_SUFFIX.test(entry.name));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolve package boundaries once per directory. A symbol index can contain tens of
+ * thousands of declarations in a monorepo, so walking and reading every ancestor for
+ * every symbol would turn a conservative check into the slowest part of the review.
+ */
+export function createReinventionScopeResolver(root) {
+    root = resolve(root);
+    const cache = new Map();
+    const scopeForDirectory = (dir) => {
+        const cached = cache.get(dir);
+        if (cached !== undefined)
+            return cached;
+        let scope;
+        if (declaresScope(dir))
+            scope = repoPath(root, dir);
+        else if (dir === root)
+            scope = '';
+        else {
+            const parent = dirname(dir);
+            scope = parent === dir || !insideRepo(root, parent) ? '' : scopeForDirectory(parent);
+        }
+        cache.set(dir, scope);
+        return scope;
+    };
+    return (file) => {
+        const abs = insideRepo(root, file);
+        return abs ? scopeForDirectory(dirname(abs)) : '';
+    };
+}
+/** Nearest language-appropriate package boundary, or the repository root. */
+export function reinventionScope(root, file) {
+    return createReinventionScopeResolver(root)(file);
+}
+function callable(node) {
+    if (Node.isFunctionDeclaration(node) || Node.isArrowFunction(node) || Node.isFunctionExpression(node))
+        return node;
+    if (!Node.isVariableDeclaration(node))
+        return undefined;
+    const init = node.getInitializer();
+    return init && (Node.isArrowFunction(init) || Node.isFunctionExpression(init)) ? init : undefined;
+}
+/**
+ * Exact program tokens for a callable, excluding its export modifier and declared
+ * name. Layout and comments may differ; parameters, types, operators, callees and
+ * literals may not. That is deliberately conservative: a name match proposes a
+ * candidate, but only equivalent executable text is deterministic evidence that a
+ * helper was reimplemented.
+ */
+export function typescriptImplementationFingerprint(node) {
+    const fn = callable(node);
+    const body = fn?.getBody();
+    if (!fn || !body)
+        return undefined;
+    const generator = !Node.isArrowFunction(fn) && fn.isGenerator();
+    const source = [
+        fn.isAsync() ? 'async' : 'sync',
+        generator ? 'generator' : 'plain',
+        '<' + fn.getTypeParameters().map((parameter) => parameter.getText()).join(',') + '>',
+        '(' + fn.getParameters().map((parameter) => parameter.getText()).join(',') + ')',
+        ':' + (fn.getReturnTypeNode()?.getText() ?? ''),
+        body.getText(),
+    ].join('\n');
+    const scanner = ts.createScanner(ts.ScriptTarget.Latest, true, ts.LanguageVariant.JSX, source);
+    const tokens = [];
+    let token = scanner.scan();
+    for (let count = 0; token !== ts.SyntaxKind.EndOfFileToken && count < 100_000; count++) {
+        tokens.push({ type: token, text: scanner.getTokenText() });
+        token = scanner.scan();
+    }
+    // Fail closed instead of hashing a shared prefix of two exceptionally large
+    // callables and presenting that collision as duplication evidence.
+    if (token !== ts.SyntaxKind.EndOfFileToken)
+        return undefined;
+    return implementationFingerprint(tokens);
+}
+/** Stable hash of compiler-visible tokens; comments and layout never enter it. */
+export function implementationFingerprint(tokens) {
+    const hash = createHash('sha256');
+    for (const token of tokens) {
+        hash.update(JSON.stringify([token.type, token.text])).update('\n');
+    }
+    return hash.digest('hex');
+}
+//# sourceMappingURL=reinvention.js.map

package/dist/report/sarif.js

@@ -10,7 +10,7 @@ function level(severity) {
 const DESCRIPTIONS = {
     'phantom-api': 'Calls an API that does not exist — hallucinated method, property, or arity',
     'phantom-dep': 'Imports a package that is not a declared dependency',
-    reinvented: 'Declares a helper that already exists in the repository',
+    reinvented: 'Adds a callable whose token-identical implementation already existed in the same package',
     'dropped-guard': 'A guard present before the change is gone after it',
     'swallowed-error': 'Error handling that discards the failure',
     'vacuous-test': 'A test that asserts nothing, or mocks the unit under test',

package/dist/selftest.js

@@ -22,7 +22,7 @@ import { stripControl } from './text.js';
 import { review } from './review.js';
 import { withTargetTree } from './snapshot.js';
 import { loadConfig } from './config.js';
-import { execFileSync } from 'node:child_process';
+import { execFileSync, spawnSync } from 'node:child_process';
 import { insideRepo, repoPath } from './fspolicy.js';
 import { Budget, parseLimits } from './budget.js';
 import { SelectionPlan, capabilitiesOf } from './plan.js';
@@ -52,6 +52,7 @@ import { summarizeRun } from './report/summary.js';
 import { wrap } from './report/terminal.js';
 import { highlight, isJsx } from './report/highlight.js';
 import { buildGround, normalizeName, readEnvManifest, relPath } from './ground.js';
+import { implementationFingerprint, reinventionScope, typescriptImplementationFingerprint } from './reinvention.js';
 import { incompleteReasons } from './bench.js';
 import { PACKAGE_NAME, PACKAGE_VERSION } from './package-meta.js';
 import { addedLinesFromPatch, inlineMarker, parseReviewFindings, reconcileInlineComments, selectInlineComments, syncInlineComments, } from './github/inline-comments.js';
@@ -83,13 +84,26 @@ function ground(files, deps = []) {
     const symbolIndex = new Map();
     for (const sf of project.getSourceFiles()) {
         const rel = sf.getFilePath().slice(root.length + 1);
+        const input = files.find((file) => file.path === rel);
         for (const [name, decls] of sf.getExportedDeclarations()) {
             const decl = decls[0];
             if (!decl)
                 continue;
+            const fingerprint = typescriptImplementationFingerprint(decl);
+            if (!fingerprint)
+                continue;
             const key = normalizeName(name);
             const list = symbolIndex.get(key) ?? [];
-            list.push({ file: rel, name, line: decl.getStartLineNumber() });
+            const before = input?.before === undefined ? undefined : beforeProject.getSourceFile('/before/' + rel);
+            const existedInBase = (before?.getExportedDeclarations().get(name) ?? []).some((baseDeclaration) => typescriptImplementationFingerprint(baseDeclaration) === fingerprint);
+            list.push({
+                file: rel,
+                name,
+                line: decl.getStartLineNumber(),
+                fingerprint,
+                existedInBase,
+                scope: reinventionScope(root, rel),
+            });
             symbolIndex.set(key, list);
         }
     }
@@ -146,14 +160,40 @@ check('resolves a scoped subpath to its package', () => {
 });
 console.log('\nreinvented');
 check('fires when a helper already exists elsewhere', () => {
+    const existing = 'export function formatMinorUnits(n: number) { return n / 100 }\n';
     const g = ground([
-        { path: 'lib/currency.ts', after: 'export function formatMinorUnits(n: number) { return n / 100 }\n' },
-        { path: 'utils/money.ts', after: 'export function formatMinorUnits(n: number) { return n / 100 }\n' },
+        { path: 'lib/currency.ts', before: existing, after: existing },
+        { path: 'utils/money.ts', after: existing },
     ]);
     const found = reinvented.run(g);
     assert.ok(found.length >= 1, 'expected a duplication finding');
     assert.equal(found[0].confidence, 'firm'); // heuristic, never claims `proven`
 });
+check('silent when matching helpers are both new in the change', () => {
+    const added = 'export function formatMinorUnits(n: number) { return n / 100 }\n';
+    const g = ground([
+        { path: 'lib/currency.ts', after: added },
+        { path: 'utils/money.ts', after: added },
+    ]);
+    assert.equal(fires(reinvented, g), false);
+});
+check('silent when the matching implementation already existed in the changed file', () => {
+    const existing = 'export function formatMinorUnits(n: number) { return n / 100 }\n';
+    const g = ground([
+        { path: 'lib/currency.ts', before: existing, after: existing },
+        { path: 'utils/money.ts', before: existing, after: existing },
+    ]);
+    assert.equal(fires(reinvented, g), false);
+});
+check('silent when the candidate only became equivalent in this change', () => {
+    const before = 'export function formatMinorUnits(n: number) { return n / 10 }\n';
+    const after = 'export function formatMinorUnits(n: number) { return n / 100 }\n';
+    const g = ground([
+        { path: 'lib/currency.ts', before, after },
+        { path: 'utils/money.ts', after },
+    ]);
+    assert.equal(fires(reinvented, g), false);
+});
 check('silent on a genuinely new name', () => {
     const g = ground([
         { path: 'lib/currency.ts', after: 'export function formatMinorUnits(n: number) { return n / 100 }\n' },
@@ -168,6 +208,125 @@ check('silent on short and generic names', () => {
     ]);
     assert.equal(fires(reinvented, g), false);
 });
+check('silent when only the helper name matches', () => {
+    const existing = 'export function runCheck(currentVersion: string, availableVersion: string) { return currentVersion !== availableVersion }\n';
+    const g = ground([
+        { path: 'web/use-app-updater.ts', before: existing, after: existing },
+        {
+            path: 'scripts/check-import-boundaries.mjs',
+            after: 'function runCheck({ srcRoot, allowlist }) { return allowlist.filter((entry) => !entry.startsWith(srcRoot)) }\n',
+        },
+    ]);
+    assert.equal(fires(reinvented, g), false);
+});
+await checkAsync('silent across package boundaries', async () => {
+    const dir = realpathSync(mkdtempSync(join(tmpdir(), 'psh-reinvented-scope-')));
+    try {
+        mkdirSync(join(dir, 'apps/web/src'), { recursive: true });
+        mkdirSync(join(dir, 'tools/scripts'), { recursive: true });
+        writeFileSync(join(dir, 'apps/web/package.json'), '{"name":"web","private":true}');
+        writeFileSync(join(dir, 'tools/scripts/package.json'), '{"name":"scripts","private":true}');
+        writeFileSync(join(dir, 'tsconfig.json'), '{"compilerOptions":{"allowJs":true},"include":["apps/**/*.mjs","tools/**/*.mjs"]}');
+        writeFileSync(join(dir, 'apps/web/src/normalize.mjs'), 'export function normalizePayload(value) { return value.trim() }\n');
+        writeFileSync(join(dir, 'tools/scripts/normalize.mjs'), 'function normalizePayload(value) { return value.trim() }\n');
+        const g = await buildGround(dir, [
+            { path: 'tools/scripts/normalize.mjs', added: new Set([1]) },
+        ]);
+        assert.equal(fires(reinvented, g), false);
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+await checkAsync('silent when only a new barrel alias gives the candidate a matching name', async () => {
+    const dir = realpathSync(mkdtempSync(join(tmpdir(), 'psh-reinvented-alias-')));
+    try {
+        mkdirSync(join(dir, 'lib'), { recursive: true });
+        mkdirSync(join(dir, 'scripts'), { recursive: true });
+        writeFileSync(join(dir, 'package.json'), '{"name":"fixture","private":true}');
+        writeFileSync(join(dir, 'tsconfig.json'), '{"include":["lib/**/*.ts","scripts/**/*.ts"]}');
+        writeFileSync(join(dir, 'lib/base.ts'), 'export function calculateVersion(current: string, available: string) { return current !== available }\n');
+        writeFileSync(join(dir, 'lib/index.ts'), "export { calculateVersion as runCheck } from './base.js'\n");
+        writeFileSync(join(dir, 'scripts/run-check.ts'), 'function runCheck(current: string, available: string) { return current !== available }\n');
+        const g = await buildGround(dir, [
+            { path: 'lib/index.ts', added: new Set([1]), before: '' },
+            { path: 'scripts/run-check.ts', added: new Set([1]) },
+        ]);
+        assert.equal(fires(reinvented, g), false);
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+check('recognizes package boundaries for every declared language family', () => {
+    const dir = realpathSync(mkdtempSync(join(tmpdir(), 'psh-reinvented-markers-')));
+    try {
+        const packages = [
+            ['typescript', 'package.json'],
+            ['python', 'pyproject.toml'],
+            ['rust', 'Cargo.toml'],
+            ['go', 'go.mod'],
+            ['jvm', 'build.gradle.kts'],
+            ['c-cpp', 'CMakeLists.txt'],
+            ['csharp', 'App.csproj'],
+            ['php', 'composer.json'],
+            ['ruby', 'Gemfile'],
+            ['solidity', 'foundry.toml'],
+        ];
+        for (const [name, marker] of packages) {
+            mkdirSync(join(dir, name, 'src'), { recursive: true });
+            writeFileSync(join(dir, name, marker), '');
+            assert.equal(reinventionScope(dir, name + '/src/file.txt'), name);
+        }
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+check('implementation fingerprints cannot confuse token boundaries with token text', () => {
+    const oneToken = implementationFingerprint([{ type: '1', text: 'x\u00002\u0000y' }]);
+    const twoTokens = implementationFingerprint([{ type: '1', text: 'x' }, { type: '2', text: 'y' }]);
+    assert.notEqual(oneToken, twoTokens);
+});
+check('public CLI rejects the name-only repro and keeps an exact-match control', () => {
+    const dir = realpathSync(mkdtempSync(join(tmpdir(), 'psh-reinvented-cli-')));
+    const cli = join(process.cwd(), 'dist', 'cli.js');
+    const git = (...args) => {
+        execFileSync('git', args, { cwd: dir, stdio: ['ignore', 'ignore', 'pipe'] });
+    };
+    const run = () => {
+        const result = spawnSync(process.execPath, [cli, 'review', '--verify-only', '--checks', 'reinvented', '--from', 'HEAD~1', '--to', 'HEAD', '--format', 'compact'], { cwd: dir, env: { ...process.env, CI: 'true' }, encoding: 'utf8' });
+        return { status: result.status, stdout: result.stdout, stderr: result.stderr };
+    };
+    try {
+        git('init', '-q', '.');
+        git('config', 'user.name', 'PowerShot Tests');
+        git('config', 'user.email', 'tests@powershot.invalid');
+        mkdirSync(join(dir, 'src'), { recursive: true });
+        mkdirSync(join(dir, 'scripts'), { recursive: true });
+        writeFileSync(join(dir, 'package.json'), '{"name":"fixture","private":true}\n');
+        writeFileSync(join(dir, 'tsconfig.json'), '{"compilerOptions":{"allowJs":true},"include":["src/**/*.ts","scripts/**/*"]}\n');
+        const existing = 'export function runCheck(currentVersion: string, availableVersion: string) { return currentVersion !== availableVersion }\n';
+        writeFileSync(join(dir, 'src/use-app-updater.ts'), existing);
+        git('add', '.');
+        git('commit', '-q', '-m', 'base');
+        writeFileSync(join(dir, 'scripts/check-import-boundaries.mjs'), 'function runCheck({ srcRoot, allowlist }) { return allowlist.filter((entry) => !entry.startsWith(srcRoot)) }\n');
+        git('add', '.');
+        git('commit', '-q', '-m', 'different helper with same name');
+        const nameOnly = run();
+        assert.equal(nameOnly.status, 0, nameOnly.stderr || nameOnly.stdout);
+        assert.doesNotMatch(nameOnly.stdout, /\[reinvented\]/);
+        writeFileSync(join(dir, 'scripts/duplicate.ts'), existing);
+        git('add', '.');
+        git('commit', '-q', '-m', 'exact duplicate');
+        const exact = run();
+        assert.equal(exact.status, 1, exact.stderr || exact.stdout);
+        assert.match(exact.stdout, /\[reinvented\]/);
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
 console.log('\ndropped-guard');
 check('fires when an early-return guard disappears', () => {
     const before = 'export function close(inv: any) {\n  if (!inv.customer) return null\n  return inv.total\n}\n';

package/dist/verifiers/foreign-reinvented.js

@@ -1,4 +1,5 @@
-import { finding, topLevelDeclarations } from './foreign-tokens.js';
+import { createReinventionScopeResolver, implementationFingerprint } from '#app/reinvention.js';
+import { finding, tokensFor, topLevelDeclarations } from './foreign-tokens.js';
 /** Names too common to mean anything across files, as in the TypeScript version. */
 const GENERIC = new Set([
     'render', 'handler', 'handle', 'create', 'update', 'remove', 'delete', 'insert',
@@ -14,6 +15,19 @@ const GENERIC = new Set([
  * repository this was the single largest source of noise.
  */
 const TESTISH = /(^|\/)(tests?|spec|__tests__)\/|(^|\/)(test_[^/]+|[^/]+_test|[^/]+\.(test|spec))\.[a-z]+$/;
+function normalized(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]/g, '');
+}
+function declarationIndex(root, pack) {
+    const index = new Map();
+    for (const [name, node] of topLevelDeclarations(root, pack)) {
+        const key = normalized(name);
+        const list = index.get(key) ?? [];
+        list.push({ name, node, fingerprint: implementationFingerprint(tokensFor(node, pack)) });
+        index.set(key, list);
+    }
+    return index;
+}
 export const foreignReinvented = {
     name: 'reinvented',
     needs: ['syntax'],
@@ -24,39 +38,71 @@ export const foreignReinvented = {
         // Keyed by language as well as name: a Ruby `charge` and a C++ `charge` are two
         // unrelated functions that happen to share a word, and calling that duplication
         // would be nonsense — nothing can be reused across the boundary anyway.
+        const scopeFor = createReinventionScopeResolver(g.root);
         const index = new Map();
+        const declarations = new Map();
         for (const file of g.foreign) {
-            if (TESTISH.test(file.path))
+            declarations.set(file.path, {
+                current: declarationIndex(file.tree.rootNode, file.pack),
+                base: file.beforeTree ? declarationIndex(file.beforeTree.rootNode, file.pack) : undefined,
+            });
+        }
+        for (const file of g.foreign) {
+            if (TESTISH.test(file.path) || !file.beforeTree)
                 continue;
-            for (const [name, decl] of topLevelDeclarations(file.tree.rootNode, file.pack)) {
-                const key = file.pack.name + '|' + name.toLowerCase().replace(/[^a-z0-9]/g, '');
-                const list = index.get(key) ?? [];
-                list.push({ file: file.path, line: decl.startPosition.row + 1 });
-                index.set(key, list);
+            const fileDeclarations = declarations.get(file.path);
+            for (const [nameKey, baseDeclarations] of fileDeclarations.base ?? []) {
+                for (const baseDeclaration of baseDeclarations) {
+                    const currentDeclaration = (fileDeclarations.current.get(nameKey) ?? []).find((declaration) => declaration.fingerprint === baseDeclaration.fingerprint);
+                    // The reusable declaration must both predate the change and remain available
+                    // at the reviewed head. A removed or rewritten helper is not a candidate.
+                    if (!currentDeclaration)
+                        continue;
+                    const key = file.pack.name + '|' + nameKey;
+                    const list = index.get(key) ?? [];
+                    list.push({
+                        file: file.path,
+                        line: currentDeclaration.node.startPosition.row + 1,
+                        fingerprint: baseDeclaration.fingerprint,
+                        scope: scopeFor(file.path),
+                    });
+                    index.set(key, list);
+                }
             }
         }
         for (const file of g.foreign) {
             if (TESTISH.test(file.path))
                 continue;
-            for (const [name, decl] of topLevelDeclarations(file.tree.rootNode, file.pack)) {
-                const line = decl.startPosition.row + 1;
-                if (!file.changed.added.has(line))
-                    continue;
-                if (name.length < 6 || GENERIC.has(name.toLowerCase()))
-                    continue;
-                const key = file.pack.name + '|' + name.toLowerCase().replace(/[^a-z0-9]/g, '');
-                const match = (index.get(key) ?? []).find((e) => e.file !== file.path);
-                // report the pair once, from the file that declares it later
-                if (!match || match.file < file.path)
-                    continue;
-                findings.push(finding(file, decl, {
-                    check: 'reinvented',
-                    severity: 'medium',
-                    confidence: 'firm',
-                    title: name + '() duplicates a declaration in ' + match.file,
-                    evidence: { oracle: file.pack.name + ' declarations', detail: 'already declared at ' + match.file + ':' + match.line },
-                    fix: 'Reuse the existing one instead of redeclaring it',
-                }));
+            const fileDeclarations = declarations.get(file.path);
+            for (const [nameKey, currentDeclarations] of fileDeclarations.current) {
+                for (const { name, node: decl, fingerprint } of currentDeclarations) {
+                    const line = decl.startPosition.row + 1;
+                    if (!file.changed.added.has(line))
+                        continue;
+                    if (name.length < 6 || GENERIC.has(name.toLowerCase()))
+                        continue;
+                    const existedHere = (fileDeclarations.base?.get(nameKey) ?? []).some((baseDeclaration) => baseDeclaration.fingerprint === fingerprint);
+                    if (existedHere)
+                        continue;
+                    const key = file.pack.name + '|' + nameKey;
+                    const scope = scopeFor(file.path);
+                    const match = (index.get(key) ?? []).find((candidate) => candidate.file !== file.path &&
+                        candidate.scope === scope &&
+                        candidate.fingerprint === fingerprint);
+                    if (!match)
+                        continue;
+                    findings.push(finding(file, decl, {
+                        check: 'reinvented',
+                        severity: 'medium',
+                        confidence: 'firm',
+                        title: name + ' repeats the implementation at ' + match.file,
+                        evidence: {
+                            oracle: file.pack.name + ' base declaration + token fingerprint',
+                            detail: 'token-identical implementation already present at ' + match.file + ':' + match.line,
+                        },
+                        fix: 'Consider reusing the existing declaration; if the separation is intentional, keep the boundary explicit',
+                    }));
+                }
             }
         }
         return findings;

package/dist/verifiers/foreign-tokens.js

@@ -68,8 +68,11 @@ export function finding(file, node, f) {
  */
 export function declaredName(decl, pack) {
     const field = decl.childForFieldName(pack.nodes.declarationName);
+    // tree-sitter-kotlin exposes the declaration identifier as a named child but
+    // assigns no field name to it. Keep the grammar field authoritative when one is
+    // present; otherwise the first identifier inside the declaration is its name.
     if (!field)
-        return undefined;
+        return nodesOfType(decl, pack.nodes.identifier)[0]?.text;
     if (field.childCount === 0)
         return field.text;
     // C and C++ wrap the name in a declarator; look inside that, never wider

package/dist/verifiers/reinvented.js

@@ -1,5 +1,6 @@
 import { SyntaxKind } from 'ts-morph';
 import { locate, normalizeName, relPath } from '#app/ground.js';
+import { createReinventionScopeResolver, typescriptImplementationFingerprint } from '#app/reinvention.js';
 /**
  * Names too generic to mean anything across files — two `render`s are usually
  * two different things, not a duplication.
@@ -15,8 +16,10 @@ function declaredNames(sf) {
     for (const fn of sf.getFunctions()) {
         const name = fn.getName();
         const id = fn.getNameNode();
-        if (name && id)
-            out.push({ name, line: fn.getStartLineNumber(), span: locate(sf, id.getStart(), id.getWidth()).span });
+        const fingerprint = typescriptImplementationFingerprint(fn);
+        if (name && id && fingerprint) {
+            out.push({ name, line: fn.getStartLineNumber(), span: locate(sf, id.getStart(), id.getWidth()).span, fingerprint });
+        }
     }
     for (const v of sf.getVariableDeclarations()) {
         const init = v.getInitializer();
@@ -24,7 +27,10 @@ function declaredNames(sf) {
             continue;
         if (init.isKind(SyntaxKind.ArrowFunction) || init.isKind(SyntaxKind.FunctionExpression)) {
             const id = v.getNameNode();
-            out.push({ name: v.getName(), line: v.getStartLineNumber(), span: locate(sf, id.getStart(), id.getWidth()).span });
+            const fingerprint = typescriptImplementationFingerprint(v);
+            if (fingerprint) {
+                out.push({ name: v.getName(), line: v.getStartLineNumber(), span: locate(sf, id.getStart(), id.getWidth()).span, fingerprint });
+            }
         }
     }
     return out;
@@ -35,19 +41,28 @@ export const reinvented = {
     needs: ['syntax'],
     run(g) {
         const findings = [];
-        for (const { sf, changed } of g.files) {
+        const scopeFor = createReinventionScopeResolver(g.root);
+        for (const { sf, changed, before } of g.files) {
             const file = relPath(sf, g.root);
+            const scope = scopeFor(file);
             // a fixture builder repeated across test files is a deliberate trade, and two
             // tests describing the same scenario naturally share a name
             if (TEST_FILE.test(file))
                 continue;
-            for (const { name, line, span } of declaredNames(sf)) {
+            const baseDeclarations = before ? declaredNames(before) : [];
+            for (const { name, line, span, fingerprint } of declaredNames(sf)) {
                 if (!changed.added.has(line))
                     continue;
                 if (name.length < 6 || GENERIC.has(name) || GENERIC.has(name.toLowerCase()))
                     continue;
-                const existing = (g.symbolIndex.get(normalizeName(name)) ?? []).filter((s) => s.file !== file);
-                const match = existing[0];
+                const existedHere = baseDeclarations.some((declaration) => normalizeName(declaration.name) === normalizeName(name) &&
+                    declaration.fingerprint === fingerprint);
+                if (existedHere)
+                    continue;
+                const match = (g.symbolIndex.get(normalizeName(name)) ?? []).find((symbol) => symbol.file !== file &&
+                    symbol.existedInBase &&
+                    symbol.scope === scope &&
+                    symbol.fingerprint === fingerprint);
                 if (!match)
                     continue;
                 findings.push({
@@ -59,12 +74,15 @@ export const reinvented = {
                     file,
                     line,
                     span,
-                    title: name + '() duplicates an existing export ' + match.file + ':' + match.name,
-                    evidence: { oracle: 'repo symbol index', detail: 'already exported from ' + match.file + ':' + match.line },
+                    title: name + '() repeats the implementation at ' + match.file + ':' + match.name,
+                    evidence: {
+                        oracle: 'base export + callable token fingerprint',
+                        detail: 'token-identical implementation already exported from ' + match.file + ':' + match.line,
+                    },
                     // Deliberately not an import statement: the correct specifier depends on the
                     // repo's module resolution, and a wrong one would be exactly the kind of
                     // confidently-wrong output this tool exists to catch.
-                    fix: 'Reuse ' + match.name + ' from ' + match.file + ' instead of redeclaring it',
+                    fix: 'Consider reusing ' + match.name + ' from ' + match.file + '; if the separation is intentional, keep the boundary explicit',
                 });
             }
         }

package/docs/architecture.md

@@ -59,7 +59,7 @@ engine. The engine does not depend on a workflow provider or terminal layout.
 |---|---|---|
 | `src/cli/` | Argument parsing, command dispatch, report publication, exit mapping | Review algorithms |
 | `src/review.ts` | One review run and its stage orchestration | CLI parsing or presentation |
-| `src/ground.ts` | Change-scoped TypeScript projects, parse trees, manifests, symbol index | Check selection |
+| `src/ground.ts` | Change-scoped TypeScript projects, parse trees, manifests, base-aware implementation index | Check selection |
 | `src/plan.ts` | File selection and per-file capability accounting | Finding generation |
 | `src/manifest.ts` | Completion state and the authoritative run record | Rendering |
 | `src/verifiers/` | Deterministic check implementations | Model calls |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xcraft/powershot",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "description": "Oracle-first code review for machine-written code, with deterministic verification and CI-ready reports.",
   "license": "Apache-2.0",
   "author": "aglumova <alina.glumova@gmail.com>",