@funeste38/allmight 1.0.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,35 @@
+# @funeste38/allmight
+
+`allmight` audits repositories for duplicate code families, picks a canonical source, and proposes safe transition patches instead of destructive cleanup.
+
+## Goals
+
+- detect exact and near duplicates
+- identify nested package mirrors and competing barrels
+- propose a canonical source per family
+- generate traceable reports and diff proposals
+- apply only safe patches on explicit request
+
+## CLI
+
+```bash
+allmight scan <root>
+allmight report <root>
+allmight propose <root>
+allmight fix-safe <root>
+allmight canonicalize <root>
+```
+
+Outputs:
+
+- `duplicate-report.json`
+- `canonical-map.json`
+- `patches/*.diff`
+- `summary.md`
+
+## Design
+
+- audit-first by default
+- never deletes divergent logic automatically
+- preserves runtime transitions with shims when possible
+- favors traceability over hidden cleanup

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function runCli(argv?: string[]): Promise<number>;

package/dist/cli/index.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { scanDuplicateFamilies } from "../core/scanner/scanDuplicateFamilies.js";
+import { applySafePatches } from "../core/patcher/applySafePatches.js";
+import { writeReportArtifacts } from "../core/report/writeReportArtifacts.js";
+function usage() {
+    console.log([
+        "allmight <command> [root] [--output <dir>]",
+        "",
+        "Commands:",
+        "  scan         scan repo and write report artifacts",
+        "  report       alias of scan",
+        "  propose      scan repo and write diff proposals",
+        "  fix-safe     scan repo, apply safe patches, then write artifacts",
+        "  canonicalize scan repo and print canonical map"
+    ].join("\n"));
+}
+function parseArgs(argv) {
+    const command = argv[0];
+    const positional = argv.filter((arg) => !arg.startsWith("--"));
+    const outputIndex = argv.indexOf("--output");
+    const outputDir = outputIndex !== -1 ? argv[outputIndex + 1] ?? "" : "";
+    const root = positional[1] ? path.resolve(positional[1]) : process.cwd();
+    return {
+        command,
+        root,
+        outputDir: outputDir || path.resolve(process.cwd(), "allmight-output")
+    };
+}
+export async function runCli(argv = process.argv.slice(2)) {
+    const { command, root, outputDir } = parseArgs(argv);
+    if (!command || command === "--help" || command === "-h") {
+        usage();
+        return 0;
+    }
+    const report = await scanDuplicateFamilies(root, { outputDir });
+    await writeReportArtifacts(report, outputDir);
+    if (command === "fix-safe") {
+        const applied = await applySafePatches(report);
+        console.log(`Applied ${applied.length} safe patches.`);
+        return 0;
+    }
+    if (command === "canonicalize") {
+        console.log(JSON.stringify(report.canonicalMap, null, 2));
+        return 0;
+    }
+    if (command === "scan" || command === "report" || command === "propose") {
+        console.log(`Scanned ${report.stats.filesScanned} files in ${root}`);
+        console.log(`Families: ${report.stats.familiesDetected}`);
+        console.log(`Patches: ${report.stats.patchesProposed} (${report.stats.safePatches} safe)`);
+        console.log(`Artifacts: ${outputDir}`);
+        return 0;
+    }
+    usage();
+    return 1;
+}
+const entryArg = process.argv[1];
+const isEntrypoint = !!entryArg && import.meta.url === new URL(`file://${entryArg.replace(/\\/g, "/")}`).href;
+if (isEntrypoint) {
+    runCli()
+        .then((code) => process.exit(code))
+        .catch((error) => {
+        console.error("allmight failed", error);
+        process.exit(1);
+    });
+}

package/dist/core/canonical/suggestCanonicalSource.d.ts

@@ -0,0 +1,2 @@
+import { DuplicateFamily } from "../../types.js";
+export declare function suggestCanonicalSource(family: DuplicateFamily): string;

package/dist/core/canonical/suggestCanonicalSource.js

@@ -0,0 +1,40 @@
+import { LEGACY_HINTS } from "../../rules/default-rules.js";
+import { toPosix } from "../../utils/text.js";
+function pathSegments(record) {
+    return toPosix(record.relativePath).split("/").filter(Boolean);
+}
+function repeatedSegmentPenalty(record) {
+    const segments = pathSegments(record);
+    let penalty = 0;
+    for (let index = 0; index < segments.length - 1; index += 1) {
+        if (segments[index] === segments[index + 1]) {
+            penalty += 15;
+        }
+    }
+    return penalty;
+}
+function semanticScore(record) {
+    const relative = toPosix(record.relativePath).toLowerCase();
+    let score = 0;
+    if (relative.includes("/packages/"))
+        score += 30;
+    if (relative.includes("/src/"))
+        score += 15;
+    if (relative.endsWith("/package.json") && record.packagePrivate === false)
+        score += 20;
+    if (record.packageVersion) {
+        const numeric = record.packageVersion.split(".").map((part) => Number(part) || 0);
+        score += numeric[0] * 10 + numeric[1] * 2 + numeric[2] * 0.2;
+    }
+    if (record.packagePrivate)
+        score -= 20;
+    if (LEGACY_HINTS.some((hint) => relative.includes(hint)))
+        score -= 35;
+    score -= repeatedSegmentPenalty(record);
+    score -= pathSegments(record).length;
+    return score;
+}
+export function suggestCanonicalSource(family) {
+    const sorted = [...family.records].sort((left, right) => semanticScore(right) - semanticScore(left));
+    return sorted[0]?.path ?? family.records[0]?.path;
+}

package/dist/core/classifier/classifyDuplicateFamily.d.ts

@@ -0,0 +1,8 @@
+import { DuplicateFamily, DuplicateType, FileFingerprint } from "../../types.js";
+type ClassificationInput = {
+    id: string;
+    records: FileFingerprint[];
+    seedType?: DuplicateType;
+};
+export declare function classifyDuplicateFamily(input: ClassificationInput): DuplicateFamily;
+export {};

package/dist/core/classifier/classifyDuplicateFamily.js

@@ -0,0 +1,129 @@
+import { DANGEROUS_PATH_HINTS, LEGACY_HINTS } from "../../rules/default-rules.js";
+import { jaccardSimilarity, sharedValues, tokenize, toPosix } from "../../utils/text.js";
+function containsAny(value, fragments) {
+    const lower = value.toLowerCase();
+    return fragments.some((fragment) => lower.includes(fragment));
+}
+function hasNestedPackage(records) {
+    const packageRecords = records.filter((record) => record.packageName);
+    return packageRecords.some((record) => /(^|\/)packages\//.test(toPosix(record.relativePath))) &&
+        packageRecords.some((record) => !/(^|\/)packages\//.test(toPosix(record.relativePath)));
+}
+function detectMixedImportRoots(records) {
+    const roots = new Set();
+    for (const record of records) {
+        for (const specifier of record.imports) {
+            if (!specifier.startsWith("."))
+                continue;
+            const first = specifier.replace(/\\/g, "/").split("/").filter(Boolean)[0];
+            if (first)
+                roots.add(first);
+        }
+    }
+    return Array.from(roots).sort();
+}
+function computeSimilarity(records) {
+    if (records.length < 2)
+        return 1;
+    let total = 0;
+    let count = 0;
+    for (let index = 0; index < records.length; index += 1) {
+        for (let other = index + 1; other < records.length; other += 1) {
+            total += jaccardSimilarity(tokenize(records[index].rawContent ?? ""), tokenize(records[other].rawContent ?? ""));
+            count += 1;
+        }
+    }
+    return count === 0 ? 0 : total / count;
+}
+function classifyType(records, seedType) {
+    if (seedType === "exact-copy")
+        return "exact-copy";
+    if (records.every((record) => record.packageName) && hasNestedPackage(records)) {
+        return "nested-package-duplicate";
+    }
+    const relativePaths = records.map((record) => toPosix(record.relativePath));
+    const similarity = computeSimilarity(records);
+    if (relativePaths.some((value) => containsAny(value, LEGACY_HINTS))) {
+        return "alias-duplicate";
+    }
+    if (records.some((record) => record.topLevelRuntimeSignals.length > 0)) {
+        return "runtime-duplicate";
+    }
+    if (relativePaths.some((value) => /(prompt|mask|image|logic)/i.test(value))) {
+        return "prompt-logic-duplicate";
+    }
+    if (relativePaths.some((value) => /(semantic|intent|context)/i.test(value))) {
+        return "semantic-duplicate";
+    }
+    if (similarity >= 0.6) {
+        return "near-duplicate";
+    }
+    if (records.some((record) => record.exports.length > 0)) {
+        return "export-duplicate";
+    }
+    return "near-duplicate";
+}
+function scoreConfidence(type, similarity) {
+    if (type === "exact-copy")
+        return 0.98;
+    if (type === "nested-package-duplicate")
+        return 0.96;
+    if (type === "alias-duplicate")
+        return Math.max(0.9, similarity);
+    if (type === "export-duplicate")
+        return Math.max(0.72, Math.min(0.9, similarity + 0.1));
+    if (type === "runtime-duplicate")
+        return Math.max(0.75, similarity);
+    if (type === "prompt-logic-duplicate")
+        return Math.max(0.7, similarity);
+    if (type === "semantic-duplicate")
+        return Math.max(0.45, similarity);
+    return Math.max(0.8, similarity);
+}
+function scoreRisk(type, records) {
+    const joined = records.map((record) => record.relativePath).join(" ").toLowerCase();
+    if (type === "runtime-duplicate" || containsAny(joined, DANGEROUS_PATH_HINTS)) {
+        return "dangerous";
+    }
+    if (type === "exact-copy" || type === "alias-duplicate" || type === "nested-package-duplicate") {
+        return "safe";
+    }
+    return "review";
+}
+export function classifyDuplicateFamily(input) {
+    const { records } = input;
+    const type = classifyType(records, input.seedType);
+    const similarity = input.seedType === "exact-copy" ? 1 : computeSimilarity(records);
+    const sharedDeclarations = records.length >= 2
+        ? records.slice(1).reduce((memo, record) => sharedValues(memo, record.declarations), records[0].declarations)
+        : [];
+    const sharedExports = records.length >= 2
+        ? records.slice(1).reduce((memo, record) => sharedValues(memo, record.exports), records[0].exports)
+        : [];
+    const mixedImportRoots = detectMixedImportRoots(records);
+    const risk = scoreRisk(type, records);
+    const confidence = scoreConfidence(type, similarity);
+    const reasonBits = [
+        `${type} detected across ${records.length} paths`,
+        sharedDeclarations.length ? `shared declarations: ${sharedDeclarations.join(", ")}` : "",
+        sharedExports.length ? `shared exports: ${sharedExports.join(", ")}` : "",
+        mixedImportRoots.length > 1 ? `mixed import roots: ${mixedImportRoots.join(", ")}` : ""
+    ].filter(Boolean);
+    return {
+        id: input.id,
+        type,
+        confidence,
+        reason: reasonBits.join(" | "),
+        risk,
+        safePatchEligible: risk === "safe" && (type === "exact-copy" || type === "alias-duplicate"),
+        files: records.map((record) => record.path),
+        records,
+        evidence: {
+            similarity,
+            sharedDeclarations,
+            sharedExports,
+            nestedPackage: hasNestedPackage(records),
+            mixedImportRoots
+        }
+    };
+}

package/dist/core/patcher/applySafePatches.d.ts

@@ -0,0 +1,2 @@
+import { PatchProposal, ScanReport } from "../../types.js";
+export declare function applySafePatches(report: ScanReport): Promise<PatchProposal[]>;

package/dist/core/patcher/applySafePatches.js

@@ -0,0 +1,34 @@
+import fs from "node:fs/promises";
+import { createLegacyReexportShim, rewriteImportsToCanonicalSource } from "./rewriters.js";
+function safePatches(report) {
+    return report.patches.filter((patch) => patch.safe);
+}
+export async function applySafePatches(report) {
+    const applied = [];
+    for (const patch of safePatches(report)) {
+        if (patch.kind === "legacy-reexport-shim" && patch.canonicalSource) {
+            const content = createLegacyReexportShim(patch.targetPath, patch.canonicalSource);
+            await fs.writeFile(patch.targetPath, `${content}\n`, "utf8");
+            applied.push(patch);
+            continue;
+        }
+        if (patch.kind === "rewrite-imports") {
+            const beforeContent = await fs.readFile(patch.targetPath, "utf8");
+            let nextContent = beforeContent;
+            for (const family of report.families) {
+                if (!family.canonicalSource)
+                    continue;
+                for (const duplicate of family.files) {
+                    if (duplicate === family.canonicalSource)
+                        continue;
+                    nextContent = rewriteImportsToCanonicalSource(nextContent, patch.targetPath, duplicate, family.canonicalSource);
+                }
+            }
+            if (nextContent !== beforeContent) {
+                await fs.writeFile(patch.targetPath, nextContent, "utf8");
+                applied.push(patch);
+            }
+        }
+    }
+    return applied;
+}

package/dist/core/patcher/buildProposedPatches.d.ts

@@ -0,0 +1,2 @@
+import { PatchProposal, ScanReport } from "../../types.js";
+export declare function buildProposedPatches(report: ScanReport): Promise<PatchProposal[]>;

package/dist/core/patcher/buildProposedPatches.js

@@ -0,0 +1,52 @@
+import fs from "node:fs/promises";
+import { slugify } from "../../utils/text.js";
+import { buildUnifiedDiff, rewriteImportsToCanonicalSource } from "./rewriters.js";
+import { buildSafePatch } from "./buildSafePatch.js";
+function canonicalLookup(report) {
+    const map = new Map();
+    for (const family of report.families) {
+        if (!family.canonicalSource)
+            continue;
+        for (const filePath of family.files) {
+            if (filePath !== family.canonicalSource) {
+                map.set(filePath, family.canonicalSource);
+            }
+        }
+    }
+    return map;
+}
+async function buildImportRewritePatches(report) {
+    const replacements = canonicalLookup(report);
+    if (!replacements.size)
+        return [];
+    const proposals = [];
+    for (const family of report.families) {
+        for (const record of family.records) {
+            const content = record.rawContent ?? (await fs.readFile(record.path, "utf8"));
+            let nextContent = content;
+            for (const [duplicatePath, canonicalPath] of replacements.entries()) {
+                nextContent = rewriteImportsToCanonicalSource(nextContent, record.path, duplicatePath, canonicalPath);
+            }
+            if (nextContent === content)
+                continue;
+            proposals.push({
+                id: `rewrite-${slugify(record.relativePath)}`,
+                familyId: family.id,
+                kind: "rewrite-imports",
+                safe: true,
+                targetPath: record.path,
+                reason: "Rewrite imports to the canonical source where the duplicate family is considered safe.",
+                diff: buildUnifiedDiff(record.relativePath, content, nextContent)
+            });
+        }
+    }
+    return proposals;
+}
+export async function buildProposedPatches(report) {
+    const proposals = [];
+    for (const family of report.families) {
+        proposals.push(...(await buildSafePatch(family)));
+    }
+    proposals.push(...(await buildImportRewritePatches(report)));
+    return proposals;
+}

package/dist/core/patcher/buildSafePatch.d.ts

@@ -0,0 +1,2 @@
+import { DuplicateFamily, PatchProposal } from "../../types.js";
+export declare function buildSafePatch(family: DuplicateFamily): Promise<PatchProposal[]>;

package/dist/core/patcher/buildSafePatch.js

@@ -0,0 +1,47 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { slugify } from "../../utils/text.js";
+import { buildUnifiedDiff, createLegacyReexportShim } from "./rewriters.js";
+function isCodeFile(filePath) {
+    return /\.(ts|tsx|js|jsx|mjs|cjs)$/i.test(filePath);
+}
+function isBarrel(recordPath, content) {
+    if (!isCodeFile(recordPath))
+        return false;
+    const lines = content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    return lines.length > 0 && lines.every((line) => line.startsWith("export "));
+}
+export async function buildSafePatch(family) {
+    const canonicalSource = family.canonicalSource;
+    if (!canonicalSource || !family.safePatchEligible) {
+        return [];
+    }
+    const proposals = [];
+    for (const record of family.records) {
+        if (record.path === canonicalSource)
+            continue;
+        if (!isCodeFile(record.path))
+            continue;
+        const beforeContent = record.rawContent ?? (await fs.readFile(record.path, "utf8"));
+        const targetLooksSafe = /(?:legacy|mirror|wrapper|copy|old|deprecated)/i.test(record.relativePath) ||
+            /(^|\/)([^/]+)\/\2(\/|$)/.test(record.relativePath) ||
+            isBarrel(record.path, beforeContent);
+        if (!targetLooksSafe)
+            continue;
+        const afterContent = createLegacyReexportShim(record.path, canonicalSource);
+        proposals.push({
+            id: `${family.id}-${slugify(record.relativePath)}`,
+            familyId: family.id,
+            kind: "legacy-reexport-shim",
+            safe: true,
+            targetPath: record.path,
+            canonicalSource,
+            reason: `Replace duplicate module with a non-breaking re-export shim to ${path.basename(canonicalSource)}.`,
+            diff: buildUnifiedDiff(record.relativePath, beforeContent, afterContent)
+        });
+    }
+    return proposals;
+}

package/dist/core/patcher/rewriters.d.ts

@@ -0,0 +1,3 @@
+export declare function createLegacyReexportShim(targetPath: string, canonicalPath: string): string;
+export declare function buildUnifiedDiff(targetPath: string, beforeContent: string, afterContent: string): string;
+export declare function rewriteImportsToCanonicalSource(sourceContent: string, sourcePath: string, duplicatePath: string, canonicalPath: string): string;

package/dist/core/patcher/rewriters.js

@@ -0,0 +1,35 @@
+import path from "node:path";
+import { removeExtension, toPosix } from "../../utils/text.js";
+function maybeJsTarget(filePath) {
+    return filePath.replace(/\.(tsx?|jsx?|mjs|cjs)$/i, ".js");
+}
+export function createLegacyReexportShim(targetPath, canonicalPath) {
+    const fromDir = path.dirname(targetPath);
+    const relative = toPosix(path.relative(fromDir, maybeJsTarget(canonicalPath)));
+    const specifier = relative.startsWith(".") ? relative : `./${relative}`;
+    return [
+        `export * from "${specifier}";`,
+        `export { default } from "${specifier}";`
+    ].join("\n");
+}
+export function buildUnifiedDiff(targetPath, beforeContent, afterContent) {
+    const beforeLines = beforeContent.split(/\r?\n/);
+    const afterLines = afterContent.split(/\r?\n/);
+    return [
+        `--- a/${toPosix(targetPath)}`,
+        `+++ b/${toPosix(targetPath)}`,
+        "@@",
+        ...beforeLines.map((line) => `-${line}`),
+        ...afterLines.map((line) => `+${line}`)
+    ].join("\n");
+}
+export function rewriteImportsToCanonicalSource(sourceContent, sourcePath, duplicatePath, canonicalPath) {
+    const fromDir = path.dirname(sourcePath);
+    const duplicateSpecifier = toPosix(path.relative(fromDir, removeExtension(duplicatePath)));
+    const canonicalSpecifier = toPosix(path.relative(fromDir, removeExtension(canonicalPath)));
+    const fromSpecifier = duplicateSpecifier.startsWith(".") ? duplicateSpecifier : `./${duplicateSpecifier}`;
+    const toSpecifier = canonicalSpecifier.startsWith(".") ? canonicalSpecifier : `./${canonicalSpecifier}`;
+    return sourceContent
+        .replaceAll(`"${fromSpecifier}"`, `"${toSpecifier}"`)
+        .replaceAll(`'${fromSpecifier}'`, `'${toSpecifier}'`);
+}

package/dist/core/report/writeReportArtifacts.d.ts

@@ -0,0 +1,2 @@
+import { ScanReport } from "../../types.js";
+export declare function writeReportArtifacts(report: ScanReport, outputDir: string): Promise<void>;

package/dist/core/report/writeReportArtifacts.js

@@ -0,0 +1,36 @@
+import path from "node:path";
+import { ensureDir, writeJson, writeText } from "../../utils/fs.js";
+function buildSummary(report) {
+    const lines = [
+        "# Allmight Summary",
+        "",
+        `Root: \`${report.root}\``,
+        `Created at: ${report.createdAt}`,
+        "",
+        `Families detected: ${report.stats.familiesDetected}`,
+        `Patches proposed: ${report.stats.patchesProposed}`,
+        `Safe patches: ${report.stats.safePatches}`,
+        "",
+        "## Families",
+        ""
+    ];
+    for (const family of report.families.slice(0, 50)) {
+        lines.push(`- \`${family.type}\` (${family.confidence.toFixed(2)}) -> \`${family.canonicalSource ?? "unknown"}\``);
+        lines.push(`  reason: ${family.reason}`);
+    }
+    return lines.join("\n");
+}
+export async function writeReportArtifacts(report, outputDir) {
+    await ensureDir(outputDir);
+    await writeJson(path.join(outputDir, "duplicate-report.json"), report);
+    await writeJson(path.join(outputDir, "canonical-map.json"), report.canonicalMap.reduce((memo, entry) => {
+        memo[entry.familyId] = entry;
+        return memo;
+    }, {}));
+    await writeText(path.join(outputDir, "summary.md"), buildSummary(report));
+    const patchesDir = path.join(outputDir, "patches");
+    await ensureDir(patchesDir);
+    for (const patch of report.patches) {
+        await writeText(path.join(patchesDir, `${patch.id}.diff`), patch.diff);
+    }
+}

package/dist/core/scanner/fileRecord.d.ts

@@ -0,0 +1,2 @@
+import { FileFingerprint } from "../../types.js";
+export declare function buildFileRecord(root: string, filePath: string, includeContent?: boolean): Promise<FileFingerprint>;

package/dist/core/scanner/fileRecord.js

@@ -0,0 +1,87 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { normalizeText, sha1, toPosix } from "../../utils/text.js";
+function extractNames(regex, value) {
+    const names = new Set();
+    for (const match of value.matchAll(regex)) {
+        const name = match[1]?.trim();
+        if (name) {
+            names.add(name);
+        }
+    }
+    return Array.from(names).sort();
+}
+function extractImports(value) {
+    const specifiers = new Set();
+    for (const match of value.matchAll(/from\s+["']([^"']+)["']/g)) {
+        specifiers.add(match[1]);
+    }
+    for (const match of value.matchAll(/require\(["']([^"']+)["']\)/g)) {
+        specifiers.add(match[1]);
+    }
+    return Array.from(specifiers).sort();
+}
+function extractRuntimeSignals(value) {
+    const signals = [
+        "listen(",
+        "app.listen(",
+        "createServer(",
+        "spawn(",
+        "setInterval(",
+        "new Worker(",
+        "new WebSocketServer("
+    ];
+    return signals.filter((signal) => value.includes(signal));
+}
+export async function buildFileRecord(root, filePath, includeContent = false) {
+    const rawContent = await fs.readFile(filePath, "utf8");
+    const ext = path.extname(filePath);
+    const normalized = normalizeText(rawContent, ext);
+    const relativePath = toPosix(path.relative(root, filePath));
+    const declarations = extractNames(/\b(?:class|function|interface|type|enum|const)\s+([A-Za-z0-9_$]+)/g, rawContent);
+    const exportedDirect = extractNames(/\bexport\s+(?:class|function|interface|type|const|enum)\s+([A-Za-z0-9_$]+)/g, rawContent);
+    const exportedNamed = [];
+    for (const match of rawContent.matchAll(/\bexport\s*{\s*([^}]+)\s*}/g)) {
+        for (const token of match[1].split(",")) {
+            const cleaned = token.split(/\s+as\s+/i)[0]?.trim();
+            if (cleaned) {
+                exportedNamed.push(cleaned);
+            }
+        }
+    }
+    const exports = Array.from(new Set([...exportedDirect, ...exportedNamed])).sort();
+    let packageName;
+    let packageVersion;
+    let packagePrivate;
+    if (path.basename(filePath) === "package.json") {
+        try {
+            const parsed = JSON.parse(rawContent);
+            if (typeof parsed.name === "string")
+                packageName = parsed.name;
+            if (typeof parsed.version === "string")
+                packageVersion = parsed.version;
+            if (typeof parsed.private === "boolean")
+                packagePrivate = parsed.private;
+        }
+        catch {
+            // ignore malformed package.json
+        }
+    }
+    return {
+        path: filePath,
+        relativePath,
+        ext,
+        size: Buffer.byteLength(rawContent),
+        hash: sha1(rawContent),
+        normalizedHash: sha1(normalized),
+        basename: path.basename(filePath),
+        declarations,
+        exports,
+        imports: extractImports(rawContent),
+        packageName,
+        packageVersion,
+        packagePrivate,
+        topLevelRuntimeSignals: extractRuntimeSignals(rawContent),
+        rawContent: includeContent ? rawContent : undefined
+    };
+}

package/dist/core/scanner/scanDuplicateFamilies.d.ts

@@ -0,0 +1,2 @@
+import { ScanOptions, ScanReport } from "../../types.js";
+export declare function scanDuplicateFamilies(root: string, _options?: ScanOptions): Promise<ScanReport>;

package/dist/core/scanner/scanDuplicateFamilies.js

@@ -0,0 +1,166 @@
+import path from "node:path";
+import { buildFileRecord } from "./fileRecord.js";
+import { classifyDuplicateFamily } from "../classifier/classifyDuplicateFamily.js";
+import { suggestCanonicalSource } from "../canonical/suggestCanonicalSource.js";
+import { buildProposedPatches } from "../patcher/buildProposedPatches.js";
+import { walkFiles } from "../../utils/fs.js";
+import { jaccardSimilarity, sharedValues, slugify, tokenize } from "../../utils/text.js";
+function pairwise(items) {
+    const pairs = [];
+    for (let index = 0; index < items.length; index += 1) {
+        for (let other = index + 1; other < items.length; other += 1) {
+            pairs.push([items[index], items[other]]);
+        }
+    }
+    return pairs;
+}
+function familyId(prefix, records) {
+    return `${prefix}-${slugify(records.map((record) => record.relativePath).join("-"))}`;
+}
+function collectExactFamilies(records) {
+    const families = [];
+    const groups = new Map();
+    for (const record of records) {
+        const group = groups.get(record.hash) ?? [];
+        group.push(record);
+        groups.set(record.hash, group);
+    }
+    for (const group of groups.values()) {
+        if (group.length < 2)
+            continue;
+        families.push(classifyDuplicateFamily({
+            id: familyId("exact-copy", group),
+            records: group,
+            seedType: "exact-copy"
+        }));
+    }
+    return families;
+}
+function collectPackageFamilies(records) {
+    const families = [];
+    const packages = records.filter((record) => record.packageName);
+    const groups = new Map();
+    for (const record of packages) {
+        const key = record.packageName;
+        const group = groups.get(key) ?? [];
+        group.push(record);
+        groups.set(key, group);
+    }
+    for (const group of groups.values()) {
+        if (group.length < 2)
+            continue;
+        families.push(classifyDuplicateFamily({
+            id: familyId("package", group),
+            records: group
+        }));
+    }
+    return families;
+}
+function collectNearFamilies(records) {
+    const families = [];
+    const byBasename = new Map();
+    for (const record of records) {
+        const group = byBasename.get(record.basename) ?? [];
+        group.push(record);
+        byBasename.set(record.basename, group);
+    }
+    for (const group of byBasename.values()) {
+        if (group.length < 2 || group.length > 12)
+            continue;
+        const related = new Set();
+        for (const [left, right] of pairwise(group)) {
+            const similarity = jaccardSimilarity(tokenize(left.rawContent ?? ""), tokenize(right.rawContent ?? ""));
+            const sharedDecls = sharedValues(left.declarations, right.declarations);
+            const sharedExports = sharedValues(left.exports, right.exports);
+            if (similarity >= 0.78 ||
+                sharedDecls.length >= 1 ||
+                sharedExports.length >= 1 ||
+                (left.packageName && right.packageName && left.packageName === right.packageName)) {
+                related.add(left);
+                related.add(right);
+            }
+        }
+        if (related.size >= 2) {
+            families.push(classifyDuplicateFamily({
+                id: familyId("near", Array.from(related)),
+                records: Array.from(related)
+            }));
+        }
+    }
+    return families;
+}
+function collectExportFamilies(records) {
+    const families = [];
+    const exportMap = new Map();
+    for (const record of records) {
+        for (const exported of record.exports) {
+            if (exported.length < 3)
+                continue;
+            const group = exportMap.get(exported) ?? [];
+            group.push(record);
+            exportMap.set(exported, group);
+        }
+    }
+    for (const group of exportMap.values()) {
+        if (group.length < 2 || group.length > 8)
+            continue;
+        families.push(classifyDuplicateFamily({
+            id: familyId("export", group),
+            records: group
+        }));
+    }
+    return families;
+}
+function dedupeFamilies(families) {
+    const seen = new Map();
+    for (const family of families) {
+        const key = `${family.type}:${family.files.map((file) => file.toLowerCase()).sort().join("|")}`;
+        if (!seen.has(key)) {
+            seen.set(key, family);
+        }
+    }
+    return Array.from(seen.values());
+}
+export async function scanDuplicateFamilies(root, _options = {}) {
+    const filePaths = await walkFiles(root);
+    const records = await Promise.all(filePaths.map((filePath) => buildFileRecord(root, filePath, true)));
+    const families = dedupeFamilies([
+        ...collectExactFamilies(records),
+        ...collectPackageFamilies(records),
+        ...collectNearFamilies(records),
+        ...collectExportFamilies(records)
+    ])
+        .map((family) => ({
+        ...family,
+        canonicalSource: suggestCanonicalSource(family)
+    }))
+        .sort((left, right) => right.confidence - left.confidence);
+    const canonicalMap = families
+        .filter((family) => family.canonicalSource)
+        .map((family) => ({
+        familyId: family.id,
+        type: family.type,
+        canonicalSource: family.canonicalSource,
+        members: family.files,
+        confidence: family.confidence,
+        reason: family.reason,
+        risk: family.risk
+    }));
+    const report = {
+        root: path.resolve(root),
+        createdAt: new Date().toISOString(),
+        stats: {
+            filesScanned: filePaths.length,
+            familiesDetected: families.length,
+            patchesProposed: 0,
+            safePatches: 0
+        },
+        families,
+        canonicalMap,
+        patches: []
+    };
+    report.patches = await buildProposedPatches(report);
+    report.stats.patchesProposed = report.patches.length;
+    report.stats.safePatches = report.patches.filter((patch) => patch.safe).length;
+    return report;
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { scanDuplicateFamilies } from "./core/scanner/scanDuplicateFamilies.js";
+export { classifyDuplicateFamily } from "./core/classifier/classifyDuplicateFamily.js";
+export { suggestCanonicalSource } from "./core/canonical/suggestCanonicalSource.js";
+export { buildSafePatch } from "./core/patcher/buildSafePatch.js";
+export { applySafePatches } from "./core/patcher/applySafePatches.js";
+export { buildProposedPatches } from "./core/patcher/buildProposedPatches.js";
+export { rewriteImportsToCanonicalSource, createLegacyReexportShim } from "./core/patcher/rewriters.js";
+export { writeReportArtifacts } from "./core/report/writeReportArtifacts.js";
+export type { CanonicalMapEntry, DuplicateFamily, DuplicateType, FileFingerprint, PatchProposal, ScanOptions, ScanReport } from "./types.js";

package/dist/index.js

@@ -0,0 +1,8 @@
+export { scanDuplicateFamilies } from "./core/scanner/scanDuplicateFamilies.js";
+export { classifyDuplicateFamily } from "./core/classifier/classifyDuplicateFamily.js";
+export { suggestCanonicalSource } from "./core/canonical/suggestCanonicalSource.js";
+export { buildSafePatch } from "./core/patcher/buildSafePatch.js";
+export { applySafePatches } from "./core/patcher/applySafePatches.js";
+export { buildProposedPatches } from "./core/patcher/buildProposedPatches.js";
+export { rewriteImportsToCanonicalSource, createLegacyReexportShim } from "./core/patcher/rewriters.js";
+export { writeReportArtifacts } from "./core/report/writeReportArtifacts.js";

package/dist/rules/default-rules.d.ts

@@ -0,0 +1,4 @@
+export declare const DEFAULT_IGNORE_DIRS: Set<string>;
+export declare const CODE_EXTENSIONS: Set<string>;
+export declare const DANGEROUS_PATH_HINTS: string[];
+export declare const LEGACY_HINTS: string[];

package/dist/rules/default-rules.js

@@ -0,0 +1,41 @@
+export const DEFAULT_IGNORE_DIRS = new Set([
+    ".git",
+    "node_modules",
+    "dist",
+    "build",
+    "coverage",
+    ".turbo",
+    ".qflush",
+    ".qflash",
+    ".next",
+    ".netlify",
+    ".vs",
+    ".vscode"
+]);
+export const CODE_EXTENSIONS = new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".json",
+    ".md"
+]);
+export const DANGEROUS_PATH_HINTS = [
+    "auth",
+    "routing",
+    "image",
+    "memory",
+    "agent",
+    "orchestration"
+];
+export const LEGACY_HINTS = [
+    "legacy",
+    "mirror",
+    "wrapper",
+    "backup",
+    "copy",
+    "old",
+    "deprecated"
+];

package/dist/types.d.ts

@@ -0,0 +1,76 @@
+export type DuplicateType = "exact-copy" | "alias-duplicate" | "near-duplicate" | "nested-package-duplicate" | "export-duplicate" | "runtime-duplicate" | "prompt-logic-duplicate" | "semantic-duplicate";
+export type PatchKind = "legacy-reexport-shim" | "rewrite-imports" | "mark-private-package" | "report-only";
+export type RiskLevel = "safe" | "review" | "dangerous";
+export type FileFingerprint = {
+    path: string;
+    relativePath: string;
+    ext: string;
+    size: number;
+    hash: string;
+    normalizedHash: string;
+    basename: string;
+    declarations: string[];
+    exports: string[];
+    imports: string[];
+    packageName?: string;
+    packageVersion?: string;
+    packagePrivate?: boolean;
+    topLevelRuntimeSignals: string[];
+    rawContent?: string;
+};
+export type FamilyEvidence = {
+    similarity?: number;
+    sharedDeclarations?: string[];
+    sharedExports?: string[];
+    nestedPackage?: boolean;
+    mixedImportRoots?: string[];
+};
+export type DuplicateFamily = {
+    id: string;
+    type: DuplicateType;
+    confidence: number;
+    reason: string;
+    risk: RiskLevel;
+    safePatchEligible: boolean;
+    files: string[];
+    records: FileFingerprint[];
+    canonicalSource?: string;
+    evidence: FamilyEvidence;
+};
+export type CanonicalMapEntry = {
+    familyId: string;
+    type: DuplicateType;
+    canonicalSource: string;
+    members: string[];
+    confidence: number;
+    reason: string;
+    risk: RiskLevel;
+};
+export type PatchProposal = {
+    id: string;
+    familyId: string;
+    kind: PatchKind;
+    safe: boolean;
+    targetPath: string;
+    canonicalSource?: string;
+    reason: string;
+    diff: string;
+};
+export type ScanStats = {
+    filesScanned: number;
+    familiesDetected: number;
+    patchesProposed: number;
+    safePatches: number;
+};
+export type ScanReport = {
+    root: string;
+    createdAt: string;
+    stats: ScanStats;
+    families: DuplicateFamily[];
+    canonicalMap: CanonicalMapEntry[];
+    patches: PatchProposal[];
+};
+export type ScanOptions = {
+    outputDir?: string;
+    includeContent?: boolean;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/fs.d.ts

@@ -0,0 +1,4 @@
+export declare function ensureDir(dirPath: string): Promise<void>;
+export declare function writeJson(filePath: string, value: unknown): Promise<void>;
+export declare function writeText(filePath: string, value: string): Promise<void>;
+export declare function walkFiles(root: string): Promise<string[]>;

package/dist/utils/fs.js

@@ -0,0 +1,36 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { DEFAULT_IGNORE_DIRS, CODE_EXTENSIONS } from "../rules/default-rules.js";
+export async function ensureDir(dirPath) {
+    await fs.mkdir(dirPath, { recursive: true });
+}
+export async function writeJson(filePath, value) {
+    await ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, JSON.stringify(value, null, 2), "utf8");
+}
+export async function writeText(filePath, value) {
+    await ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, value, "utf8");
+}
+export async function walkFiles(root) {
+    const found = [];
+    async function walk(current) {
+        const entries = await fs.readdir(current, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                if (DEFAULT_IGNORE_DIRS.has(entry.name)) {
+                    continue;
+                }
+                await walk(fullPath);
+                continue;
+            }
+            if (!CODE_EXTENSIONS.has(path.extname(entry.name))) {
+                continue;
+            }
+            found.push(fullPath);
+        }
+    }
+    await walk(root);
+    return found.sort();
+}

package/dist/utils/text.d.ts

@@ -0,0 +1,8 @@
+export declare function toPosix(input: string): string;
+export declare function sha1(value: string): string;
+export declare function normalizeText(raw: string, ext: string): string;
+export declare function tokenize(raw: string): Set<string>;
+export declare function jaccardSimilarity(a: Set<string>, b: Set<string>): number;
+export declare function sharedValues(a: string[], b: string[]): string[];
+export declare function slugify(value: string): string;
+export declare function removeExtension(filePath: string): string;

package/dist/utils/text.js

@@ -0,0 +1,51 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+export function toPosix(input) {
+    return input.replace(/\\/g, "/");
+}
+export function sha1(value) {
+    return createHash("sha1").update(value).digest("hex");
+}
+export function normalizeText(raw, ext) {
+    let value = raw;
+    if (ext !== ".json") {
+        value = value.replace(/\/\*[\s\S]*?\*\//g, "");
+        value = value.replace(/^\s*\/\/.*$/gm, "");
+    }
+    return value.replace(/\s+/g, " ").trim();
+}
+export function tokenize(raw) {
+    return new Set(raw
+        .toLowerCase()
+        .split(/[^a-z0-9_@/.-]+/i)
+        .map((token) => token.trim())
+        .filter((token) => token.length >= 2));
+}
+export function jaccardSimilarity(a, b) {
+    if (!a.size && !b.size) {
+        return 1;
+    }
+    let intersection = 0;
+    for (const token of a) {
+        if (b.has(token)) {
+            intersection += 1;
+        }
+    }
+    const union = new Set([...a, ...b]).size;
+    return union === 0 ? 0 : intersection / union;
+}
+export function sharedValues(a, b) {
+    const bSet = new Set(b);
+    return Array.from(new Set(a.filter((value) => bSet.has(value)))).sort();
+}
+export function slugify(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 80);
+}
+export function removeExtension(filePath) {
+    const ext = path.extname(filePath);
+    return filePath.slice(0, filePath.length - ext.length);
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@funeste38/allmight",
+  "version": "1.0.0",
+  "description": "Audit-first duplicate detector and canonicalization helper for Funesterie repositories.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "allmight": "dist/cli/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p .",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run build && npm test",
+    "test": "vitest run",
+    "scan:spyder": "node dist/cli/index.js scan D:/SPYDER --output docs/reports/spyder"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jEFFLEZ/allmight.git"
+  },
+  "bugs": {
+    "url": "https://github.com/jEFFLEZ/allmight/issues"
+  },
+  "homepage": "https://github.com/jEFFLEZ/allmight#readme",
+  "author": "jEFFLEZ",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "@types/node": "^24.12.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.7"
+  }
+}