infinite-tag 0.1.1

package/dist/src/frameworks/static-html.js

@@ -0,0 +1,137 @@
+import { join } from "node:path";
+import { fileExists, indentBlock, normalizeAppRelativePath, readRequiredFile, readWorkspacePackageJson, writeFileIfChanged } from "./shared.js";
+const managedStartMarker = "<!-- infinite:start -->";
+const managedEndMarker = "<!-- infinite:end -->";
+export const staticHtmlAdapter = {
+    id: "static-html",
+    displayName: "Static HTML",
+    detect(root) {
+        if (!fileExists(root, "index.html")) {
+            return null;
+        }
+        const pkg = readWorkspacePackageJson(root);
+        if (pkg) {
+            if (packageJsonHasFrameworkDeps(pkg)) {
+                // A real framework dependency is present — this is ambiguous, stay cautious.
+                return {
+                    framework: "static-html",
+                    confidence: 0.6,
+                    files: ["index.html"],
+                    assumptions: [
+                        "index.html sits next to a package.json, so this may be a framework app rather than a plain static site. Confirm before applying."
+                    ]
+                };
+            }
+            // package.json exists but only has build/lint/test tooling — treat as confidently static.
+        }
+        return {
+            framework: "static-html",
+            confidence: 0.78,
+            files: ["index.html"],
+            assumptions: ["Static HTML wiring will target index.html directly."]
+        };
+    },
+    plan(root) {
+        const detected = this.detect(root);
+        const blockers = [];
+        if (!fileExists(root, "index.html")) {
+            blockers.push("Static HTML apply requires an index.html file.");
+        }
+        else if (!readRequiredFile(root, "index.html").includes("</head>")) {
+            blockers.push("Static HTML apply requires a closing </head> tag.");
+        }
+        return {
+            files: ["index.html"],
+            applyMode: blockers.length === 0 ? "supported" : "plan-only",
+            instructions: [],
+            assumptions: [
+                "Static HTML wiring uses direct public snippets rather than framework-specific runtime hooks."
+            ],
+            blockers,
+            confidence: detected?.confidence ?? 0.75
+        };
+    },
+    apply(context) {
+        const appRoot = context.appRoot === "." ? context.root : join(context.root, context.appRoot);
+        const htmlPath = "index.html";
+        const rootRelativeHtmlPath = normalizeAppRelativePath(context.appRoot, htmlPath);
+        const html = readRequiredFile(appRoot, htmlPath);
+        if (!html.includes("</head>")) {
+            throw new Error("Static HTML apply requires a closing </head> tag.");
+        }
+        const providerSnippets = context.plan.instructions
+            .filter((instruction) => instruction.path === rootRelativeHtmlPath && instruction.provider)
+            .map((instruction) => instruction.snippet.trim())
+            .filter((snippet) => snippet.length > 0);
+        const managedBlock = [
+            managedStartMarker,
+            ...providerSnippets.flatMap((snippet) => ["", indentBlock(snippet, 2)]),
+            "",
+            managedEndMarker
+        ].join("\n");
+        const managedPattern = new RegExp(`${escapeForRegExp(managedStartMarker)}[\\s\\S]*?${escapeForRegExp(managedEndMarker)}`, "m");
+        const nextHtml = html.includes(managedStartMarker)
+            ? html.replace(managedPattern, managedBlock)
+            : html.replace("</head>", `${managedBlock}\n</head>`);
+        const changedFiles = [];
+        if (writeFileIfChanged(appRoot, htmlPath, nextHtml)) {
+            changedFiles.push(rootRelativeHtmlPath);
+        }
+        return {
+            changedFiles,
+            warnings: []
+        };
+    },
+    uninstall(context) {
+        const appRoot = context.appRoot === "." ? context.root : join(context.root, context.appRoot);
+        const htmlPath = "index.html";
+        const rootRelativeHtmlPath = normalizeAppRelativePath(context.appRoot, htmlPath);
+        const restoredFiles = [];
+        const warnings = [];
+        if (!fileExists(appRoot, htmlPath)) {
+            warnings.push(`Managed file already absent: ${htmlPath}`);
+            return { removedFiles: [], restoredFiles, warnings };
+        }
+        const html = readRequiredFile(appRoot, htmlPath);
+        const managedPattern = new RegExp(`${escapeForRegExp(managedStartMarker)}[\\s\\S]*?${escapeForRegExp(managedEndMarker)}\\n?`, "m");
+        const nextHtml = html.replace(managedPattern, "");
+        if (nextHtml === html) {
+            warnings.push(`No managed Infinite block found in ${htmlPath}.`);
+        }
+        else {
+            if (!context.dryRun) {
+                writeFileIfChanged(appRoot, htmlPath, nextHtml);
+            }
+            restoredFiles.push(rootRelativeHtmlPath);
+        }
+        return { removedFiles: [], restoredFiles, warnings };
+    }
+};
+function escapeForRegExp(source) {
+    return source.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+// Framework-like dependency names that indicate the site is NOT a plain static
+// HTML project, making the static-html adapter a risky choice.
+const frameworkDepNames = new Set([
+    "react",
+    "react-dom",
+    "vue",
+    "svelte",
+    "@sveltejs/kit",
+    "next",
+    "nuxt",
+    "vite",
+    "@angular/core",
+    "gatsby",
+    "remix",
+    "@remix-run/react",
+    "astro",
+    "solid-js"
+]);
+function packageJsonHasFrameworkDeps(pkg) {
+    const allDeps = [
+        ...Object.keys(pkg.dependencies ?? {}),
+        ...Object.keys(pkg.devDependencies ?? {})
+    ];
+    return allDeps.some((dep) => frameworkDepNames.has(dep));
+}

package/dist/src/frameworks/vite-react.d.ts

@@ -0,0 +1,2 @@
+import type { FrameworkAdapter } from "../types.js";
+export declare const viteReactAdapter: FrameworkAdapter;

package/dist/src/frameworks/vite-react.js

@@ -0,0 +1,274 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { buildAnalyticsModuleSource, hasExistingUnmanagedFile, isManagedInfiniteFile, removeManagedFile } from "./managed-files.js";
+import { fileExists, firstExistingPath, hasDependency, normalizeAppRelativePath, readRequiredFile, writeFileIfChanged } from "./shared.js";
+const mainCandidates = ["src/main.tsx", "src/main.jsx", "src/main.ts", "src/main.js"];
+const analyticsModulePath = "src/lib/infinite-analytics.ts";
+const importLine = 'import { installInfiniteInstrumentation } from "./lib/infinite-analytics"';
+const bootLine = "installInfiniteInstrumentation()";
+export const viteReactAdapter = {
+    id: "vite-react",
+    displayName: "Vite React",
+    detect(root) {
+        if (!hasDependency(root, "vite") || !hasDependency(root, "react")) {
+            return null;
+        }
+        if (!fileExists(root, "index.html")) {
+            return null;
+        }
+        const mainFile = firstExistingPath(root, mainCandidates);
+        if (!mainFile) {
+            return null;
+        }
+        return {
+            framework: "vite-react",
+            confidence: 0.92,
+            files: ["index.html", mainFile, analyticsModulePath],
+            assumptions: ["Vite React wiring will target the main entrypoint and index.html."]
+        };
+    },
+    plan(root) {
+        const detected = this.detect(root);
+        const mainFile = detected?.files[1] ?? "src/main.tsx";
+        const blockers = [];
+        if (!fileExists(root, mainFile)) {
+            blockers.push("Vite React apply requires a src/main.* entrypoint.");
+        }
+        else {
+            const mainSource = readRequiredFile(root, mainFile);
+            if (!mainSource.includes("ReactDOM.createRoot(")) {
+                blockers.push("Vite React apply only supports simple main entrypoints with ReactDOM.createRoot().");
+            }
+            if (findImportSectionEnd(mainSource) === null) {
+                blockers.push("Vite React apply requires a simple import block at the top of src/main.*.");
+            }
+        }
+        if (hasExistingUnmanagedFile(root, analyticsModulePath)) {
+            blockers.push("Vite React apply will not overwrite an existing unmanaged src/lib/infinite-analytics.ts file.");
+        }
+        return {
+            files: ["index.html", mainFile, analyticsModulePath],
+            applyMode: blockers.length === 0 ? "supported" : "plan-only",
+            instructions: blockers.length === 0
+                ? [
+                    {
+                        path: mainFile,
+                        action: "modify",
+                        description: "Import and invoke installInfiniteInstrumentation() once before the React app bootstraps.",
+                        snippet: `${importLine}\n\n${bootLine}`
+                    }
+                ]
+                : [],
+            assumptions: [
+                "Vite React public IDs can be surfaced through VITE_* environment variables or direct public wiring."
+            ],
+            blockers,
+            confidence: detected?.confidence ?? 0.88
+        };
+    },
+    apply(context) {
+        const appRoot = context.appRoot === "." ? context.root : join(context.root, context.appRoot);
+        const mainFile = selectMainFile(appRoot, context.plan.files, context.appRoot);
+        const rootRelativeMainFile = normalizeAppRelativePath(context.appRoot, mainFile);
+        const rootRelativeAnalyticsFile = normalizeAppRelativePath(context.appRoot, analyticsModulePath);
+        const currentMain = readRequiredFile(appRoot, mainFile);
+        if (!currentMain.includes("ReactDOM.createRoot(")) {
+            throw new Error("Vite React apply only supports simple main entrypoints with ReactDOM.createRoot().");
+        }
+        const analyticsModuleAbsolutePath = join(appRoot, analyticsModulePath);
+        if (existsSync(analyticsModuleAbsolutePath) &&
+            !isManagedInfiniteFile(readFileSync(analyticsModuleAbsolutePath, "utf8"))) {
+            throw new Error(`Refusing to overwrite existing unmanaged analytics module at ${rootRelativeAnalyticsFile}.`);
+        }
+        const nextMain = upsertMainEntrypoint(currentMain);
+        const nextAnalyticsModule = buildAnalyticsModuleSource(context.plan);
+        const changedFiles = [];
+        if (writeFileIfChanged(appRoot, mainFile, nextMain)) {
+            changedFiles.push(rootRelativeMainFile);
+        }
+        if (writeFileIfChanged(appRoot, analyticsModulePath, nextAnalyticsModule)) {
+            changedFiles.push(rootRelativeAnalyticsFile);
+        }
+        return {
+            changedFiles,
+            warnings: []
+        };
+    },
+    uninstall(context) {
+        const appRoot = context.appRoot === "." ? context.root : join(context.root, context.appRoot);
+        const removedFiles = [];
+        const restoredFiles = [];
+        const warnings = [];
+        if (hasExistingUnmanagedFile(appRoot, analyticsModulePath)) {
+            throw new Error(`Refusing to remove ${analyticsModulePath} because it no longer looks managed by Infinite. Remove it manually if it should go.`);
+        }
+        let wiringFullyRemoved = true;
+        const mainFile = selectMainFile(appRoot, context.manifest.files, context.appRoot);
+        const mainAbsolutePath = join(appRoot, mainFile);
+        if (!existsSync(mainAbsolutePath)) {
+            warnings.push(`Managed main entrypoint already absent: ${mainFile}`);
+        }
+        else {
+            const currentMain = readFileSync(mainAbsolutePath, "utf8");
+            const nextMain = removeMainWiring(currentMain);
+            if (nextMain !== currentMain) {
+                if (!context.dryRun) {
+                    writeFileIfChanged(appRoot, mainFile, nextMain);
+                }
+                restoredFiles.push(normalizeAppRelativePath(context.appRoot, mainFile));
+            }
+            if (nextMain.includes(importLine) || nextMain.includes(bootLine)) {
+                wiringFullyRemoved = false;
+                warnings.push(`Could not remove all instrumentation wiring from ${mainFile} automatically. Remove the leftover lines manually.`);
+            }
+        }
+        if (wiringFullyRemoved) {
+            const removal = removeManagedFile(appRoot, analyticsModulePath, context.dryRun);
+            if (removal.removed) {
+                removedFiles.push(normalizeAppRelativePath(context.appRoot, analyticsModulePath));
+            }
+            if (removal.warning) {
+                warnings.push(removal.warning);
+            }
+        }
+        return { removedFiles, restoredFiles, warnings };
+    }
+};
+function removeMainWiring(source) {
+    let next = source.replace(`${importLine}\n`, "");
+    next = next.replace(`\n${bootLine}\n`, "");
+    return next;
+}
+function selectMainFile(root, planFiles, appRoot) {
+    const appRelativeFiles = planFiles.map((file) => appRoot === "." ? file : file.replace(`${appRoot}/`, ""));
+    const matched = appRelativeFiles.find((file) => mainCandidates.includes(file));
+    if (matched) {
+        return matched;
+    }
+    const fallback = firstExistingPath(root, mainCandidates);
+    if (!fallback) {
+        throw new Error("Unable to resolve the Vite React main entrypoint.");
+    }
+    return fallback;
+}
+function upsertMainEntrypoint(source) {
+    const importSectionEnd = findImportSectionEnd(source);
+    if (importSectionEnd === null) {
+        throw new Error("Vite React apply requires a simple import block at the top of src/main.*.");
+    }
+    let next = source;
+    if (!next.includes(importLine)) {
+        next = `${next.slice(0, importSectionEnd)}${importLine}\n${next.slice(importSectionEnd)}`;
+    }
+    if (!next.includes(bootLine)) {
+        const refreshedImportSectionEnd = findImportSectionEnd(next);
+        if (refreshedImportSectionEnd === null) {
+            throw new Error("Unable to refresh the Vite React import block after inserting analytics wiring.");
+        }
+        next = `${next.slice(0, refreshedImportSectionEnd)}\n${bootLine}\n${next.slice(refreshedImportSectionEnd)}`;
+    }
+    return next;
+}
+// Finds the end offset of the first contiguous import section, treating each
+// import statement as complete only once its brackets balance — so multi-line
+// imports (`import {\n  a,\n  b\n} from "x"`) are never split mid-statement.
+function findImportSectionEnd(source) {
+    const firstImport = source.match(/^import\b/m);
+    if (!firstImport || firstImport.index === undefined) {
+        return null;
+    }
+    let position = firstImport.index;
+    while (isImportKeywordAt(source, position)) {
+        const statementEnd = consumeImportStatement(source, position);
+        if (statementEnd === null) {
+            return null;
+        }
+        position = statementEnd;
+    }
+    return position;
+}
+// Returns true only when "import" at `pos` is a keyword — i.e. not followed
+// by an identifier character. This prevents `importantSetup()` from being
+// mistaken for an import statement.
+function isImportKeywordAt(source, pos) {
+    if (!source.startsWith("import", pos)) {
+        return false;
+    }
+    // The character immediately after "import" must not be an identifier char.
+    const charAfter = source[pos + 6];
+    if (charAfter === undefined) {
+        // "import" at end-of-string — not a real import, stop scanning
+        return false;
+    }
+    return !/[A-Za-z0-9_$]/.test(charAfter);
+}
+function consumeImportStatement(source, start) {
+    // Scan character-by-character from the start of the statement, tracking string
+    // and comment state so delimiters inside them never affect the bracket depth.
+    // The statement ends at the first newline reached with balanced brackets
+    // (outside any string/comment), matching multi-line imports like
+    // `import {\n  a,\n  b\n} from "x"`. Returns the offset just past that newline,
+    // or null if the brackets never balance / a block comment is left unclosed.
+    let depth = 0;
+    let index = start;
+    let stringQuote = null;
+    let inBlockComment = false;
+    while (index < source.length) {
+        const ch = source[index];
+        const next = source[index + 1];
+        if (inBlockComment) {
+            if (ch === "*" && next === "/") {
+                inBlockComment = false;
+                index += 2;
+                continue;
+            }
+            index += 1;
+            continue;
+        }
+        if (stringQuote !== null) {
+            if (ch === "\\") {
+                index += 2; // skip the escaped character
+                continue;
+            }
+            if (ch === stringQuote) {
+                stringQuote = null;
+            }
+            index += 1;
+            continue;
+        }
+        if (ch === "/" && next === "/") {
+            // Line comment: jump to the newline, which the newline branch handles.
+            const newlineIndex = source.indexOf("\n", index);
+            if (newlineIndex === -1) {
+                return depth <= 0 ? source.length : null;
+            }
+            index = newlineIndex;
+            continue;
+        }
+        if (ch === "/" && next === "*") {
+            inBlockComment = true;
+            index += 2;
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === "`") {
+            stringQuote = ch;
+            index += 1;
+            continue;
+        }
+        if (ch === "{" || ch === "(") {
+            depth += 1;
+        }
+        else if (ch === "}" || ch === ")") {
+            depth -= 1;
+        }
+        else if (ch === "\n" && depth <= 0) {
+            return index + 1;
+        }
+        index += 1;
+    }
+    // End of source with no trailing newline.
+    if (inBlockComment) {
+        return null;
+    }
+    return depth <= 0 ? source.length : null;
+}

package/dist/src/index.d.ts

@@ -0,0 +1,12 @@
+export type { ApplyMode, ApplyResult, FrameworkAdapter, FrameworkApplyContext, FrameworkApplyResult, FrameworkUninstallContext, FrameworkUninstallResult, Ga4PublicArtifact, InspectResult, InstallInstruction, InstallManifest, InstallPlan, PackageManager, PackageManagerCommands, PackageManagerDetection, PosthogPublicArtifact, ProviderAdapter, ProviderId, ProviderPlanDraft, RepoStatus, SupportedFramework, UninstallResult, VerifyResult, WorkspaceInstallArtifacts, XPublicArtifact } from "./types.js";
+export { applyInstallation } from "./apply.js";
+export { frameworkAdapters, getFrameworkAdapter, isSupportedFramework } from "./frameworks/index.js";
+export { detectRepoStatus, inspectWorkspace } from "./inspect.js";
+export { computeContentHashes, installManifestPath, installManifestRelativePath, readInstallManifest, writeInstallManifest, writeInstallManifestIfChanged } from "./manifest.js";
+export { buildPackageManagerCommands, detectPackageManager } from "./package-manager.js";
+export { planInstallation } from "./plan.js";
+export { getProviderAdapter, providerAdapters } from "./providers/index.js";
+export { runCli } from "./cli.js";
+export { uninstallInstallation } from "./uninstall.js";
+export { resolveWorkspaceArtifacts } from "./workspace-artifacts.js";
+export { verifyInstallation } from "./verify.js";

package/dist/src/index.js

@@ -0,0 +1,11 @@
+export { applyInstallation } from "./apply.js";
+export { frameworkAdapters, getFrameworkAdapter, isSupportedFramework } from "./frameworks/index.js";
+export { detectRepoStatus, inspectWorkspace } from "./inspect.js";
+export { computeContentHashes, installManifestPath, installManifestRelativePath, readInstallManifest, writeInstallManifest, writeInstallManifestIfChanged } from "./manifest.js";
+export { buildPackageManagerCommands, detectPackageManager } from "./package-manager.js";
+export { planInstallation } from "./plan.js";
+export { getProviderAdapter, providerAdapters } from "./providers/index.js";
+export { runCli } from "./cli.js";
+export { uninstallInstallation } from "./uninstall.js";
+export { resolveWorkspaceArtifacts } from "./workspace-artifacts.js";
+export { verifyInstallation } from "./verify.js";

package/dist/src/inspect.d.ts

@@ -0,0 +1,10 @@
+import { resolveConfinedAppRoot } from "./frameworks/shared.js";
+import type { InspectResult, PackageManager, RepoStatus } from "./types.js";
+export interface InspectOptions {
+    appRoot?: string;
+    packageManager?: PackageManager;
+}
+export declare function detectRepoStatus(root: string): RepoStatus;
+export { resolveConfinedAppRoot };
+export declare function detectUnmanagedProviders(appRoot: string): string[];
+export declare function inspectWorkspace(root: string, options?: InspectOptions): InspectResult;

package/dist/src/inspect.js

@@ -0,0 +1,150 @@
+import { existsSync, readFileSync } from "node:fs";
+import { readdirSync } from "node:fs";
+import { join, relative } from "node:path";
+import { spawnSync } from "node:child_process";
+import { frameworkAdapters } from "./frameworks/index.js";
+import { resolveConfinedAppRoot } from "./frameworks/shared.js";
+import { isManagedInfiniteFile } from "./frameworks/managed-files.js";
+import { readInstallManifest } from "./manifest.js";
+import { detectPackageManager } from "./package-manager.js";
+export function detectRepoStatus(root) {
+    const insideWorkTree = spawnSync("git", ["-C", root, "rev-parse", "--is-inside-work-tree"], {
+        encoding: "utf8"
+    });
+    if (insideWorkTree.status !== 0) {
+        return "not-a-git-repo";
+    }
+    const status = spawnSync("git", ["-C", root, "status", "--porcelain"], {
+        encoding: "utf8"
+    });
+    if (status.status !== 0) {
+        return "not-a-git-repo";
+    }
+    return status.stdout.trim().length > 0 ? "dirty" : "clean";
+}
+export { resolveConfinedAppRoot };
+function discoverCandidateRoots(root, appRoot) {
+    if (appRoot) {
+        return [resolveConfinedAppRoot(root, appRoot)];
+    }
+    const candidates = [root];
+    const appsDirectory = join(root, "apps");
+    if (existsSync(appsDirectory)) {
+        const entries = readdirSync(appsDirectory, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort();
+        for (const entryName of entries) {
+            candidates.push(join(appsDirectory, entryName));
+        }
+    }
+    return candidates;
+}
+const providerScanCandidates = [
+    "index.html",
+    "src/main.tsx",
+    "src/main.jsx",
+    "src/lib/infinite-analytics.ts",
+    "app/layout.tsx",
+    "pages/_app.tsx",
+    "lib/infinite-analytics.ts"
+];
+function scanContentsForProviders(contents, detected) {
+    // GA4: match the actual tag loader URL or the gtag() function call signature.
+    // Bare "google" or "gtag" strings in prose will not trigger this.
+    if (contents.includes("googletagmanager.com/gtag") || contents.includes("gtag(")) {
+        detected.add("ga4");
+    }
+    // PostHog: match the initialisation call or the CDN host, not the bare product name.
+    // Ordinary copy mentioning "posthog" (e.g. in a README or marketing page) will not trigger.
+    if (contents.includes("posthog.init(") || contents.includes("i.posthog.com")) {
+        detected.add("posthog");
+    }
+    // X/Twitter pixel: match its actual tag signatures only.
+    if (contents.includes("twq(") || contents.includes("static.ads-twitter.com")) {
+        detected.add("x");
+    }
+}
+function stripManagedHtmlBlocks(contents) {
+    return contents.replace(/<!-- infinite:start -->[\s\S]*?<!-- infinite:end -->/g, "");
+}
+export function detectUnmanagedProviders(appRoot) {
+    const detected = new Set();
+    for (const candidate of providerScanCandidates) {
+        const absolutePath = join(appRoot, candidate);
+        if (!existsSync(absolutePath)) {
+            continue;
+        }
+        const contents = readFileSync(absolutePath, "utf8");
+        if (isManagedInfiniteFile(contents)) {
+            continue;
+        }
+        scanContentsForProviders(stripManagedHtmlBlocks(contents), detected);
+    }
+    return [...detected];
+}
+function detectExistingProviders(root, appRoot) {
+    const manifest = readInstallManifest(root);
+    if (manifest) {
+        return manifest.providers;
+    }
+    const detected = new Set();
+    for (const candidate of providerScanCandidates) {
+        const absolutePath = join(appRoot, candidate);
+        if (!existsSync(absolutePath)) {
+            continue;
+        }
+        scanContentsForProviders(readFileSync(absolutePath, "utf8"), detected);
+    }
+    return [...detected];
+}
+export function inspectWorkspace(root, options = {}) {
+    const packageManagerDetection = detectPackageManager(root, options.packageManager);
+    const packageManager = packageManagerDetection.kind;
+    const repoStatus = detectRepoStatus(root);
+    const candidates = discoverCandidateRoots(root, options.appRoot);
+    let bestMatch;
+    for (const candidate of candidates) {
+        for (const adapter of frameworkAdapters) {
+            const result = adapter.detect(candidate);
+            if (!result) {
+                continue;
+            }
+            if (!bestMatch || result.confidence > bestMatch.result.confidence) {
+                bestMatch = { root: candidate, result };
+            }
+        }
+    }
+    if (!bestMatch || !bestMatch.result) {
+        return {
+            framework: "unsupported",
+            appRoot: ".",
+            packageManager,
+            confidence: 0.2,
+            existingProviders: [],
+            repoStatus,
+            assumptions: packageManagerDetection.kind === "ambiguous"
+                ? ["Multiple lockfiles were detected. Founder choice is required before printing install commands."]
+                : [],
+            blockers: ["Unsupported repository shape for instrumentation."],
+            detectedFiles: packageManagerDetection.lockfiles
+        };
+    }
+    const relativeAppRoot = relative(root, bestMatch.root) || ".";
+    const existingProviders = detectExistingProviders(root, bestMatch.root);
+    const assumptions = [...bestMatch.result.assumptions];
+    if (packageManagerDetection.kind === "ambiguous") {
+        assumptions.push("Multiple lockfiles were detected. Founder choice is required before printing install commands.");
+    }
+    return {
+        framework: bestMatch.result.framework,
+        appRoot: relativeAppRoot,
+        packageManager,
+        confidence: bestMatch.result.confidence,
+        existingProviders,
+        repoStatus,
+        assumptions,
+        blockers: [],
+        detectedFiles: bestMatch.result.files
+    };
+}

package/dist/src/manifest.d.ts

@@ -0,0 +1,10 @@
+import type { InstallManifest } from "./types.js";
+export declare const installManifestRelativePath = ".infinite/install.json";
+export declare function installManifestPath(root: string): string;
+export declare function readInstallManifest(root: string): InstallManifest | null;
+export declare function writeInstallManifest(root: string, manifest: InstallManifest): string;
+export declare function writeInstallManifestIfChanged(root: string, manifest: InstallManifest): {
+    changed: boolean;
+    manifestPath: string;
+};
+export declare function computeContentHashes(root: string, files: string[]): Record<string, string>;