@funeste38/allmight 1.0.0 → 1.1.0

package/dist/cli/index.js

@@ -3,40 +3,80 @@ 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";
+import { analyzeRepoFamilies } from "../core/multi/analyzeRepoFamilies.js";
+import { analyzePublishDoctor } from "../core/doctor/analyzePublishDoctor.js";
+import { writeDoctorArtifacts, writeMultiRootArtifacts } from "../core/report/writeMultiRootArtifacts.js";
 function usage() {
     console.log([
-        "allmight <command> [root] [--output <dir>]",
+        "allmight <command> [args] [--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"
+        "  canonicalize scan repo and print canonical map",
+        "  multi-scan   scan multiple roots and write repo family + publish risk artifacts",
+        "  doctor publish       verify package/dist/bin/global-install coherence",
+        "  doctor bin           focus on bin targets and install shadows",
+        "  doctor install-shadow detect global/local install mismatch for a package"
     ].join("\n"));
 }
 function parseArgs(argv) {
-    const command = argv[0];
-    const positional = argv.filter((arg) => !arg.startsWith("--"));
+    const positional = argv.filter((arg, index) => !(arg === "--output" || argv[index - 1] === "--output") && !arg.startsWith("--output="));
     const outputIndex = argv.indexOf("--output");
-    const outputDir = outputIndex !== -1 ? argv[outputIndex + 1] ?? "" : "";
-    const root = positional[1] ? path.resolve(positional[1]) : process.cwd();
+    const inlineOutput = argv.find((arg) => arg.startsWith("--output="));
+    const outputDir = outputIndex !== -1
+        ? argv[outputIndex + 1] ?? ""
+        : inlineOutput
+            ? inlineOutput.slice("--output=".length)
+            : "";
     return {
-        command,
-        root,
+        command: positional[0],
+        positional,
         outputDir: outputDir || path.resolve(process.cwd(), "allmight-output")
     };
 }
 export async function runCli(argv = process.argv.slice(2)) {
-    const { command, root, outputDir } = parseArgs(argv);
+    const { command, positional, outputDir } = parseArgs(argv);
     if (!command || command === "--help" || command === "-h") {
         usage();
         return 0;
     }
-    const report = await scanDuplicateFamilies(root, { outputDir });
+    if (command === "multi-scan") {
+        const roots = positional.slice(1).map((root) => path.resolve(root));
+        if (roots.length === 0) {
+            usage();
+            return 1;
+        }
+        const report = await analyzeRepoFamilies(roots);
+        await writeMultiRootArtifacts(report, outputDir);
+        console.log(`Scanned ${roots.length} roots.`);
+        console.log(`Repo families: ${report.repoFamilies.length}`);
+        console.log(`Command shadows: ${report.commandShadows.length}`);
+        console.log(`Artifacts: ${outputDir}`);
+        return 0;
+    }
+    if (command === "doctor") {
+        const mode = positional[1];
+        if (!mode || !["publish", "bin", "install-shadow"].includes(mode)) {
+            usage();
+            return 1;
+        }
+        const root = positional[2] ? path.resolve(positional[2]) : process.cwd();
+        const report = await analyzePublishDoctor(root);
+        await writeDoctorArtifacts(report, outputDir, mode);
+        console.log(`Doctor ${mode} -> ${report.publishRisk}`);
+        console.log(`Artifacts: ${outputDir}`);
+        return 0;
+    }
+    const root = positional[1] ? path.resolve(positional[1]) : process.cwd();
+    let report = await scanDuplicateFamilies(root, { outputDir });
     await writeReportArtifacts(report, outputDir);
     if (command === "fix-safe") {
         const applied = await applySafePatches(report);
+        report = await scanDuplicateFamilies(root, { outputDir });
+        await writeReportArtifacts(report, outputDir);
         console.log(`Applied ${applied.length} safe patches.`);
         return 0;
     }

package/dist/core/doctor/analyzePublishDoctor.d.ts

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

package/dist/core/doctor/analyzePublishDoctor.js

@@ -0,0 +1,80 @@
+import path from "node:path";
+import { readGlobalNpmState, findCommandPaths } from "../../utils/system.js";
+import { toPosix } from "../../utils/text.js";
+import { readRepoRootMeta } from "../repo/readRepoRootMeta.js";
+function toRisk(reasons) {
+    if (reasons.some((reason) => /mismatch|missing|shadow|different/i.test(reason))) {
+        return "dangerous";
+    }
+    if (reasons.length > 0) {
+        return "review";
+    }
+    return "safe";
+}
+function buildInstallShadowFinding(root, packageName, packageVersion, bin, globalInfo, globalPrefix) {
+    const commandPaths = findCommandPaths(bin);
+    const reasons = [];
+    const normalizedRoot = toPosix(path.resolve(root)).toLowerCase();
+    const normalizedResolved = toPosix(String(globalInfo?.resolved || "").replace(/^file:/i, "")).toLowerCase();
+    if (commandPaths.length === 0) {
+        reasons.push("bin is not available on PATH");
+    }
+    if (globalInfo?.resolved && normalizedResolved && normalizedResolved !== normalizedRoot) {
+        reasons.push("global install resolves to a different root");
+    }
+    if (globalInfo?.version && packageVersion && globalInfo.version !== packageVersion) {
+        reasons.push("global install version differs from package.json");
+    }
+    if (commandPaths.some((entry) => !toPosix(entry).toLowerCase().startsWith(toPosix(globalPrefix).toLowerCase()))) {
+        reasons.push("command shadow detected outside the npm global prefix");
+    }
+    if (!globalInfo && packageName) {
+        reasons.push("package is not installed globally");
+    }
+    return {
+        bin,
+        commandPaths,
+        globalPackageVersion: globalInfo?.version,
+        globalPackageResolved: globalInfo?.resolved,
+        risk: toRisk(reasons),
+        reason: reasons.join(" | ") || "install path looks coherent"
+    };
+}
+export async function analyzePublishDoctor(root) {
+    const meta = await readRepoRootMeta(root);
+    const npmState = readGlobalNpmState();
+    const globalPackageInfo = meta.packageName ? npmState.packages[meta.packageName] : undefined;
+    const installShadow = meta.binEntries.map((entry) => (buildInstallShadowFinding(meta.root, meta.packageName, meta.packageVersion, entry.name, globalPackageInfo, npmState.prefix)));
+    const reasons = [];
+    if (!meta.packageName)
+        reasons.push("missing package.json name");
+    if (meta.packagePrivate === true)
+        reasons.push("package is marked private");
+    if (!meta.hasDist)
+        reasons.push("dist/ is missing");
+    if (!meta.hasSrc)
+        reasons.push("src/ is missing");
+    if (meta.packageLockVersion && meta.packageVersion && meta.packageLockVersion !== meta.packageVersion) {
+        reasons.push("package-lock version mismatch");
+    }
+    if (meta.binEntries.some((entry) => !entry.exists)) {
+        reasons.push("at least one bin target is missing");
+    }
+    if (installShadow.some((entry) => entry.risk === "dangerous")) {
+        reasons.push("install shadow or global mismatch detected");
+    }
+    return {
+        createdAt: new Date().toISOString(),
+        root: meta.root,
+        packageName: meta.packageName,
+        packageVersion: meta.packageVersion,
+        packagePrivate: meta.packagePrivate,
+        packageLockVersion: meta.packageLockVersion,
+        hasDist: meta.hasDist,
+        hasSrc: meta.hasSrc,
+        bins: meta.binEntries,
+        installShadow,
+        publishRisk: toRisk(reasons),
+        reasons
+    };
+}

package/dist/core/multi/analyzeRepoFamilies.d.ts

@@ -0,0 +1,2 @@
+import { MultiRepoReport } from "../../types.js";
+export declare function analyzeRepoFamilies(roots: string[]): Promise<MultiRepoReport>;

package/dist/core/multi/analyzeRepoFamilies.js

@@ -0,0 +1,215 @@
+import path from "node:path";
+import { levenshteinDistance, toPosix } from "../../utils/text.js";
+import { readRepoRootMeta } from "../repo/readRepoRootMeta.js";
+function pathPenalty(root) {
+    const normalized = toPosix(root).toLowerCase();
+    let penalty = 0;
+    if (normalized.includes("/poubele/"))
+        penalty += 80;
+    if (normalized.includes("/tmp/"))
+        penalty += 60;
+    if (normalized.includes("/dump/"))
+        penalty += 40;
+    if (normalized.includes("/backup/"))
+        penalty += 45;
+    if (normalized.includes("/copy/"))
+        penalty += 35;
+    if (normalized.includes("/old/"))
+        penalty += 35;
+    if (normalized.includes("/gpt6.0/"))
+        penalty += 20;
+    return penalty;
+}
+function versionScore(version) {
+    if (!version)
+        return 0;
+    const [major = 0, minor = 0, patch = 0] = version.split(".").map((value) => Number(value) || 0);
+    return major * 30 + minor * 4 + patch * 0.2;
+}
+function canonicalScore(meta, family) {
+    const basename = meta.basename.toLowerCase();
+    const packageName = meta.packageName?.toLowerCase() ?? "";
+    let score = 0;
+    if (basename === family)
+        score += 70;
+    if (packageName.endsWith(`/${family}`) || packageName === family)
+        score += 45;
+    if (basename.includes(family))
+        score += 18;
+    if (meta.hasSrc)
+        score += 20;
+    if (meta.hasDist)
+        score += 10;
+    if (meta.binEntries.length > 0)
+        score += 12;
+    if (meta.binEntries.every((entry) => entry.exists))
+        score += 10;
+    if (meta.packagePrivate === true)
+        score -= 30;
+    score += versionScore(meta.packageVersion);
+    score -= pathPenalty(meta.root);
+    return score;
+}
+function memberRole(root, canonicalRoot) {
+    if (root === canonicalRoot) {
+        return "canonical";
+    }
+    const normalized = toPosix(root).toLowerCase();
+    if (normalized.includes("/funesterie/") || normalized.includes("/a11/")) {
+        return "transition";
+    }
+    return "mirror";
+}
+function collectCollisions(members, selector) {
+    const groups = new Map();
+    for (const meta of members) {
+        for (const entry of selector(meta)) {
+            const existing = groups.get(entry.name) ?? {
+                name: entry.name,
+                roots: [],
+                packages: []
+            };
+            existing.roots.push(meta.root);
+            if (entry.packageName) {
+                existing.packages.push(entry.packageName);
+            }
+            groups.set(entry.name, existing);
+        }
+    }
+    return Array.from(groups.values())
+        .filter((entry) => entry.roots.length > 1)
+        .map((entry) => ({
+        ...entry,
+        roots: Array.from(new Set(entry.roots)),
+        packages: Array.from(new Set(entry.packages))
+    }))
+        .sort((left, right) => right.roots.length - left.roots.length || left.name.localeCompare(right.name));
+}
+function publishRiskLevel(score) {
+    if (score >= 60)
+        return "dangerous";
+    if (score >= 30)
+        return "review";
+    return "safe";
+}
+function familyReasons(family, canonicalRoot, members, packageCollisions, binCollisions) {
+    const reasons = [`canonical source proposed for ${family}: ${canonicalRoot}`];
+    if (members.some((meta) => pathPenalty(meta.root) > 0 && meta.packagePrivate !== true)) {
+        reasons.push("legacy or trash-area copy still looks publishable");
+    }
+    if (packageCollisions.length > 0) {
+        reasons.push("same package name appears in multiple roots");
+    }
+    if (binCollisions.length > 0) {
+        reasons.push("same CLI bin is exposed by multiple roots");
+    }
+    if (members.some((meta) => meta.binEntries.some((entry) => !entry.exists))) {
+        reasons.push("at least one bin target is missing");
+    }
+    return reasons;
+}
+function buildRepoFamilyReport(family, members) {
+    const scoredMembers = members
+        .map((meta) => ({ meta, score: canonicalScore(meta, family) }))
+        .sort((left, right) => right.score - left.score || left.meta.root.localeCompare(right.meta.root));
+    const canonicalRoot = scoredMembers[0]?.meta.root ?? members[0].root;
+    const packageCollisions = collectCollisions(members, (meta) => (meta.packageName ? [{ name: meta.packageName, packageName: meta.packageName }] : []));
+    const binCollisions = collectCollisions(members, (meta) => (meta.binEntries.map((entry) => ({ name: entry.name, packageName: meta.packageName }))));
+    const reasons = familyReasons(family, canonicalRoot, members, packageCollisions, binCollisions);
+    let publishRiskScore = 0;
+    publishRiskScore += packageCollisions.length * 28;
+    publishRiskScore += binCollisions.length * 24;
+    publishRiskScore += members.filter((meta) => pathPenalty(meta.root) > 0 && meta.packagePrivate !== true).length * 12;
+    publishRiskScore += members.filter((meta) => meta.binEntries.some((entry) => !entry.exists)).length * 12;
+    publishRiskScore = Math.min(100, publishRiskScore);
+    const memberReports = scoredMembers.map(({ meta, score }) => ({
+        root: meta.root,
+        packageName: meta.packageName,
+        packageVersion: meta.packageVersion,
+        role: memberRole(meta.root, canonicalRoot),
+        score,
+        bins: meta.binEntries.map((entry) => entry.name).sort()
+    }));
+    return {
+        family,
+        canonicalRoot,
+        canonicalPackage: scoredMembers[0]?.meta.packageName,
+        members: memberReports,
+        mirrors: memberReports.filter((member) => member.role === "mirror").map((member) => member.root),
+        transitions: memberReports.filter((member) => member.role === "transition").map((member) => member.root),
+        packageCollisions,
+        binCollisions,
+        publishRiskScore,
+        publishRisk: publishRiskLevel(publishRiskScore),
+        reasons
+    };
+}
+function isSimilarCommand(left, right) {
+    if (left === right)
+        return false;
+    const distance = levenshteinDistance(left, right);
+    if (distance <= 1)
+        return true;
+    return left.startsWith(right) || right.startsWith(left);
+}
+function commandShadowRisk(left, right, roots) {
+    if (levenshteinDistance(left, right) <= 1 || roots.length > 1) {
+        return "dangerous";
+    }
+    return "review";
+}
+function buildCommandShadows(roots) {
+    const commandToRoots = new Map();
+    for (const meta of roots) {
+        for (const entry of meta.binEntries) {
+            const existing = commandToRoots.get(entry.name) ?? new Set();
+            existing.add(meta.root);
+            commandToRoots.set(entry.name, existing);
+        }
+    }
+    const commands = Array.from(commandToRoots.keys()).sort();
+    const shadows = [];
+    for (let index = 0; index < commands.length; index += 1) {
+        for (let other = index + 1; other < commands.length; other += 1) {
+            const left = commands[index];
+            const right = commands[other];
+            if (!isSimilarCommand(left, right))
+                continue;
+            const rootsForPair = Array.from(new Set([
+                ...(commandToRoots.get(left) ?? new Set()),
+                ...(commandToRoots.get(right) ?? new Set())
+            ])).sort();
+            shadows.push({
+                left,
+                right,
+                distance: levenshteinDistance(left, right),
+                roots: rootsForPair,
+                risk: commandShadowRisk(left, right, rootsForPair),
+                reason: `commands ${left} and ${right} are visually close and may be mistaken during install or publish`
+            });
+        }
+    }
+    return shadows.sort((left, right) => left.distance - right.distance || left.left.localeCompare(right.left));
+}
+export async function analyzeRepoFamilies(roots) {
+    const uniqueRoots = Array.from(new Set(roots.map((root) => path.resolve(root))));
+    const metas = await Promise.all(uniqueRoots.map((root) => readRepoRootMeta(root)));
+    const familyBuckets = new Map();
+    for (const meta of metas) {
+        for (const family of meta.familyTags) {
+            const existing = familyBuckets.get(family) ?? [];
+            existing.push(meta);
+            familyBuckets.set(family, existing);
+        }
+    }
+    const repoFamilies = Array.from(familyBuckets.entries())
+        .filter(([, members]) => members.length >= 2)
+        .map(([family, members]) => buildRepoFamilyReport(family, members))
+        .sort((left, right) => right.publishRiskScore - left.publishRiskScore || left.family.localeCompare(right.family));
+    return {
+        createdAt: new Date().toISOString(),
+        roots: metas,
+        repoFamilies,
+        commandShadows: buildCommandShadows(metas)
+    };
+}

package/dist/core/repo/readRepoRootMeta.d.ts

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

package/dist/core/repo/readRepoRootMeta.js

@@ -0,0 +1,120 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { toPosix } from "../../utils/text.js";
+function normalizeLower(value) {
+    return value.trim().toLowerCase();
+}
+function hasFamilyHint(value, hints) {
+    const normalized = normalizeLower(value);
+    return hints.some((hint) => normalized.includes(hint));
+}
+function detectFamilyTags(root, packageName) {
+    const sources = [path.basename(root), packageName ?? ""].filter(Boolean);
+    const tags = new Set();
+    if (sources.some((value) => hasFamilyHint(value, ["qflush", "qflash"]))) {
+        tags.add("qflush");
+    }
+    if (sources.some((value) => hasFamilyHint(value, ["envapt", "envaptex"]))) {
+        tags.add("envapt");
+    }
+    if (sources.some((value) => hasFamilyHint(value, ["allmight"]))) {
+        tags.add("allmight");
+    }
+    if (sources.some((value) => hasFamilyHint(value, ["spyder"]))) {
+        tags.add("spyder");
+    }
+    return Array.from(tags).sort();
+}
+function readPackageLockVersion(parsed) {
+    if (typeof parsed.version === "string" && parsed.version.trim()) {
+        return parsed.version;
+    }
+    const packages = parsed.packages;
+    if (!packages || typeof packages !== "object") {
+        return undefined;
+    }
+    const rootPackage = packages[""];
+    if (!rootPackage || typeof rootPackage !== "object") {
+        return undefined;
+    }
+    const version = rootPackage.version;
+    return typeof version === "string" && version.trim() ? version : undefined;
+}
+function normalizeBinEntries(root, rawBin) {
+    const entries = new Map();
+    if (typeof rawBin === "string" && rawBin.trim()) {
+        entries.set(path.basename(root), rawBin.trim());
+    }
+    else if (rawBin && typeof rawBin === "object") {
+        for (const [name, target] of Object.entries(rawBin)) {
+            if (typeof target === "string" && target.trim()) {
+                entries.set(name, target.trim());
+            }
+        }
+    }
+    return Array.from(entries.entries())
+        .map(([name, target]) => {
+        const absoluteTarget = path.resolve(root, target);
+        return fs.access(absoluteTarget)
+            .then(() => ({
+            name,
+            target,
+            absoluteTarget,
+            exists: true
+        }))
+            .catch(() => ({
+            name,
+            target,
+            absoluteTarget,
+            exists: false
+        }));
+    });
+}
+export async function readRepoRootMeta(root) {
+    const resolvedRoot = path.resolve(root);
+    const packageJsonPath = path.join(resolvedRoot, "package.json");
+    const packageLockPath = path.join(resolvedRoot, "package-lock.json");
+    const srcPath = path.join(resolvedRoot, "src");
+    const distPath = path.join(resolvedRoot, "dist");
+    let packageName;
+    let packageVersion;
+    let packagePrivate;
+    let rawBin;
+    try {
+        const rawPackageJson = await fs.readFile(packageJsonPath, "utf8");
+        const parsed = JSON.parse(rawPackageJson);
+        packageName = typeof parsed.name === "string" ? parsed.name : undefined;
+        packageVersion = typeof parsed.version === "string" ? parsed.version : undefined;
+        packagePrivate = typeof parsed.private === "boolean" ? parsed.private : undefined;
+        rawBin = parsed.bin;
+    }
+    catch {
+        // root without package.json is still a valid scan root
+    }
+    let packageLockVersion;
+    try {
+        const rawPackageLock = await fs.readFile(packageLockPath, "utf8");
+        const parsed = JSON.parse(rawPackageLock);
+        packageLockVersion = readPackageLockVersion(parsed);
+    }
+    catch {
+        packageLockVersion = undefined;
+    }
+    const [hasSrc, hasDist] = await Promise.all([
+        fs.access(srcPath).then(() => true).catch(() => false),
+        fs.access(distPath).then(() => true).catch(() => false)
+    ]);
+    const binEntries = await Promise.all(normalizeBinEntries(resolvedRoot, rawBin));
+    return {
+        root: resolvedRoot,
+        basename: path.basename(resolvedRoot),
+        packageName,
+        packageVersion,
+        packagePrivate,
+        packageLockVersion,
+        familyTags: detectFamilyTags(toPosix(resolvedRoot), packageName),
+        hasSrc,
+        hasDist,
+        binEntries
+    };
+}

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

@@ -0,0 +1,3 @@
+import { MultiRepoReport, PublishDoctorReport } from "../../types.js";
+export declare function writeMultiRootArtifacts(report: MultiRepoReport, outputDir: string): Promise<void>;
+export declare function writeDoctorArtifacts(report: PublishDoctorReport, outputDir: string, mode: string): Promise<void>;

package/dist/core/report/writeMultiRootArtifacts.js

@@ -0,0 +1,73 @@
+import path from "node:path";
+import { ensureDir, writeJson, writeText } from "../../utils/fs.js";
+function buildMultiScanSummary(report) {
+    const lines = [
+        "# Allmight Multi Scan",
+        "",
+        `Created at: ${report.createdAt}`,
+        `Roots scanned: ${report.roots.length}`,
+        `Families detected: ${report.repoFamilies.length}`,
+        `Command shadows: ${report.commandShadows.length}`,
+        "",
+        "## Families",
+        ""
+    ];
+    for (const family of report.repoFamilies) {
+        lines.push(`- ${family.family}: canonical=${family.canonicalRoot}`);
+        lines.push(`  risk=${family.publishRisk} (${family.publishRiskScore})`);
+    }
+    if (report.commandShadows.length > 0) {
+        lines.push("", "## Command Shadows", "");
+        for (const shadow of report.commandShadows) {
+            lines.push(`- ${shadow.left} vs ${shadow.right}: ${shadow.risk}`);
+        }
+    }
+    return lines.join("\n");
+}
+function buildDoctorSummary(report, mode) {
+    const lines = [
+        "# Allmight Doctor",
+        "",
+        `Mode: ${mode}`,
+        `Root: ${report.root}`,
+        `Package: ${report.packageName ?? "unknown"}`,
+        `Version: ${report.packageVersion ?? "unknown"}`,
+        `Risk: ${report.publishRisk}`,
+        ""
+    ];
+    if (report.reasons.length > 0) {
+        lines.push("## Reasons", "");
+        for (const reason of report.reasons) {
+            lines.push(`- ${reason}`);
+        }
+    }
+    if (report.installShadow.length > 0) {
+        lines.push("", "## Install Shadow", "");
+        for (const entry of report.installShadow) {
+            lines.push(`- ${entry.bin}: ${entry.reason}`);
+        }
+    }
+    return lines.join("\n");
+}
+export async function writeMultiRootArtifacts(report, outputDir) {
+    await ensureDir(outputDir);
+    await writeJson(path.join(outputDir, "repo-families.json"), report.repoFamilies);
+    await writeJson(path.join(outputDir, "publish-risk-report.json"), {
+        createdAt: report.createdAt,
+        roots: report.roots,
+        repoFamilies: report.repoFamilies,
+        commandShadows: report.commandShadows
+    });
+    await writeJson(path.join(outputDir, "command-shadow-report.json"), report.commandShadows);
+    await writeText(path.join(outputDir, "summary.md"), buildMultiScanSummary(report));
+}
+export async function writeDoctorArtifacts(report, outputDir, mode) {
+    await ensureDir(outputDir);
+    const fileName = mode === "install-shadow"
+        ? "install-shadow-report.json"
+        : mode === "bin"
+            ? "bin-risk-report.json"
+            : "publish-risk-report.json";
+    await writeJson(path.join(outputDir, fileName), report);
+    await writeText(path.join(outputDir, "summary.md"), buildDoctorSummary(report, mode));
+}

package/dist/index.d.ts

@@ -6,4 +6,7 @@ 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";
+export { analyzeRepoFamilies } from "./core/multi/analyzeRepoFamilies.js";
+export { analyzePublishDoctor } from "./core/doctor/analyzePublishDoctor.js";
+export { writeMultiRootArtifacts, writeDoctorArtifacts } from "./core/report/writeMultiRootArtifacts.js";
+export type { CanonicalMapEntry, CommandShadow, DuplicateFamily, DuplicateType, FileFingerprint, InstallShadowFinding, MultiRepoReport, PatchProposal, PublishDoctorReport, RepoFamilyReport, RepoRootMeta, ScanOptions, ScanReport } from "./types.js";

package/dist/index.js

@@ -6,3 +6,6 @@ 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 { analyzeRepoFamilies } from "./core/multi/analyzeRepoFamilies.js";
+export { analyzePublishDoctor } from "./core/doctor/analyzePublishDoctor.js";
+export { writeMultiRootArtifacts, writeDoctorArtifacts } from "./core/report/writeMultiRootArtifacts.js";

package/dist/types.d.ts

@@ -74,3 +74,88 @@ export type ScanOptions = {
     outputDir?: string;
     includeContent?: boolean;
 };
+export type RepoBinEntry = {
+    name: string;
+    target: string;
+    exists: boolean;
+    absoluteTarget: string;
+};
+export type RepoRootMeta = {
+    root: string;
+    basename: string;
+    packageName?: string;
+    packageVersion?: string;
+    packagePrivate?: boolean;
+    packageLockVersion?: string;
+    familyTags: string[];
+    hasSrc: boolean;
+    hasDist: boolean;
+    binEntries: RepoBinEntry[];
+};
+export type RepoFamilyMemberRole = "canonical" | "transition" | "mirror";
+export type RepoFamilyMember = {
+    root: string;
+    packageName?: string;
+    packageVersion?: string;
+    role: RepoFamilyMemberRole;
+    score: number;
+    bins: string[];
+};
+export type RepoCollision = {
+    name: string;
+    roots: string[];
+    packages: string[];
+};
+export type CommandShadow = {
+    left: string;
+    right: string;
+    distance: number;
+    roots: string[];
+    risk: RiskLevel;
+    reason: string;
+};
+export type RepoFamilyReport = {
+    family: string;
+    canonicalRoot: string;
+    canonicalPackage?: string;
+    members: RepoFamilyMember[];
+    mirrors: string[];
+    transitions: string[];
+    packageCollisions: RepoCollision[];
+    binCollisions: RepoCollision[];
+    publishRiskScore: number;
+    publishRisk: RiskLevel;
+    reasons: string[];
+};
+export type MultiRepoReport = {
+    createdAt: string;
+    roots: RepoRootMeta[];
+    repoFamilies: RepoFamilyReport[];
+    commandShadows: CommandShadow[];
+};
+export type GlobalPackageInfo = {
+    version?: string;
+    resolved?: string;
+};
+export type InstallShadowFinding = {
+    bin: string;
+    commandPaths: string[];
+    globalPackageVersion?: string;
+    globalPackageResolved?: string;
+    risk: RiskLevel;
+    reason: string;
+};
+export type PublishDoctorReport = {
+    createdAt: string;
+    root: string;
+    packageName?: string;
+    packageVersion?: string;
+    packagePrivate?: boolean;
+    packageLockVersion?: string;
+    hasDist: boolean;
+    hasSrc: boolean;
+    bins: RepoBinEntry[];
+    installShadow: InstallShadowFinding[];
+    publishRisk: RiskLevel;
+    reasons: string[];
+};

package/dist/utils/system.d.ts

@@ -0,0 +1,9 @@
+export declare function findCommandPaths(commandName: string): string[];
+export declare function readGlobalNpmState(): {
+    prefix: string;
+    root: string;
+    packages: Record<string, {
+        version?: string;
+        resolved?: string;
+    }>;
+};

package/dist/utils/system.js

@@ -0,0 +1,48 @@
+import { spawnSync } from "node:child_process";
+function runCommand(command, args) {
+    try {
+        const result = spawnSync(command, args, {
+            encoding: "utf8",
+            windowsHide: true,
+            shell: process.platform === "win32"
+        });
+        return {
+            status: result.status,
+            stdout: String(result.stdout ?? ""),
+            stderr: String(result.stderr ?? "")
+        };
+    }
+    catch (error) {
+        return {
+            status: 1,
+            stdout: "",
+            stderr: String(error?.message ?? error)
+        };
+    }
+}
+export function findCommandPaths(commandName) {
+    const result = process.platform === "win32"
+        ? runCommand("where.exe", [commandName])
+        : runCommand("which", ["-a", commandName]);
+    if (result.status !== 0) {
+        return [];
+    }
+    return result.stdout
+        .split(/\r?\n/g)
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+export function readGlobalNpmState() {
+    const prefix = runCommand("npm", ["prefix", "-g"]).stdout.trim();
+    const root = runCommand("npm", ["root", "-g"]).stdout.trim();
+    const listResult = runCommand("npm", ["list", "-g", "--depth=0", "--json"]);
+    let packages = {};
+    try {
+        const parsed = JSON.parse(listResult.stdout);
+        packages = parsed.dependencies ?? {};
+    }
+    catch {
+        packages = {};
+    }
+    return { prefix, root, packages };
+}

package/dist/utils/text.d.ts

@@ -6,3 +6,4 @@ export declare function jaccardSimilarity(a: Set<string>, b: Set<string>): numbe
 export declare function sharedValues(a: string[], b: string[]): string[];
 export declare function slugify(value: string): string;
 export declare function removeExtension(filePath: string): string;
+export declare function levenshteinDistance(left: string, right: string): number;

package/dist/utils/text.js

@@ -49,3 +49,27 @@ export function removeExtension(filePath) {
     const ext = path.extname(filePath);
     return filePath.slice(0, filePath.length - ext.length);
 }
+export function levenshteinDistance(left, right) {
+    if (left === right)
+        return 0;
+    if (!left.length)
+        return right.length;
+    if (!right.length)
+        return left.length;
+    const rows = right.length + 1;
+    const cols = left.length + 1;
+    const matrix = Array.from({ length: rows }, () => Array(cols).fill(0));
+    for (let row = 0; row < rows; row += 1) {
+        matrix[row][0] = row;
+    }
+    for (let col = 0; col < cols; col += 1) {
+        matrix[0][col] = col;
+    }
+    for (let row = 1; row < rows; row += 1) {
+        for (let col = 1; col < cols; col += 1) {
+            const substitutionCost = right[row - 1] === left[col - 1] ? 0 : 1;
+            matrix[row][col] = Math.min(matrix[row - 1][col] + 1, matrix[row][col - 1] + 1, matrix[row - 1][col - 1] + substitutionCost);
+        }
+    }
+    return matrix[rows - 1][cols - 1];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@funeste38/allmight",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Audit-first duplicate detector and canonicalization helper for Funesterie repositories.",
   "type": "module",
   "main": "dist/index.js",