@clearlydev/nx-archweave 0.1.1 → 0.2.0

package/dist/generators/allow-builds/render.js

@@ -1,82 +0,0 @@
-import { yamlPackageKey } from '@nx-archweave/template-engine';
-const ALLOW_BUILDS_LABEL = {
-    allowed: 'already true',
-    denied: 'false → true',
-    pending: 'awaiting a decision → true',
-    other: 'another value → true',
-    absent: 'added (true)',
-};
-export function renderAllowBuildsReport(report) {
-    const rebuild = `pnpm rebuild ${report.packages.join(' ')}`;
-    if (report.refused === undefined) {
-        const lines = [
-            `allow-builds — ${report.applied ? 'applied' : 'preview (nothing written)'}`,
-            '',
-            `pnpm-workspace.yaml › ${report.target}`,
-            ...report.changes.map((change) => `  ${change.name}: ${label(report.target, change.previous)}`),
-            '',
-        ];
-        if (report.namesUnchecked)
-            lines.push('The names were not checked: there is no pnpm-lock.yaml.', '');
-        if (report.applied) {
-            lines.push(`Running: ${rebuild}`);
-        }
-        else {
-            lines.push(`Then: ${rebuild}`, "Allowing a build lets that package's install script run with your user's permissions.", '', `To apply: pnpm nx g @clearlydev/nx-archweave:allow-builds --packages=${report.packages.join(',')} --apply`);
-        }
-        return lines.join('\n');
-    }
-    const head = 'allow-builds — refused (nothing written)';
-    switch (report.refused) {
-        case 'npm':
-            return [
-                head,
-                'This is an npm workspace: allow-builds edits pnpm settings only. npm runs dependency install scripts',
-                'itself unless ignore-scripts is set, so there is nothing to re-allow; npm 11 records an approval with',
-                `  npm install-scripts approve ${report.packages.join(' ')}`,
-            ].join('\n');
-        case 'yarn':
-            return [
-                head,
-                'This is a yarn workspace: allow-builds edits pnpm settings only. yarn classic runs dependency',
-                'install scripts itself; yarn berry runs them unless .yarnrc.yml sets enableScripts: false —',
-                'remove that line (or set it to true) and run `yarn install` to let them run.',
-            ].join('\n');
-        case 'bun':
-            return [
-                head,
-                'This is a bun workspace: allow-builds edits pnpm settings only. bun blocks the install scripts of',
-                'dependencies outside its trusted list; `bun pm untrusted` lists the blocked ones, and',
-                `  bun pm trust ${report.packages.join(' ')}`,
-                'runs their scripts and records them in package.json trustedDependencies.',
-            ].join('\n');
-        case 'no-package-manager':
-            return [head, 'There is no pnpm-lock.yaml or pnpm-workspace.yaml here — allow-builds edits pnpm settings only.'].join('\n');
-        case 'no-workspace-yaml':
-            return [
-                head,
-                'This pnpm project has no pnpm-workspace.yaml, where pnpm keeps its build decisions. Add one with',
-                '  allowBuilds:',
-                ...report.packages.map((name) => `    ${yamlPackageKey(name)}: true`),
-                `then run "${rebuild}".`,
-            ].join('\n');
-        case 'unknown-packages':
-            return [
-                head,
-                `These packages are not in pnpm-lock.yaml: ${report.unknown.join(', ')} — check the names; only an installed package has a build to run.`,
-            ].join('\n');
-        case 'unrecognized':
-            return [
-                head,
-                `pnpm-workspace.yaml is in a shape allow-builds does not edit: ${report.reason}.`,
-                `Instead, allow ${report.packages.join(', ')} in pnpm-workspace.yaml yourself — "<package>: true" under allowBuilds`,
-                `(pnpm 11; pnpm 10 from 10.28), or a "- <package>" item under onlyBuiltDependencies on older pnpm 10 — then run "${rebuild}".`,
-            ].join('\n');
-    }
-}
-function label(target, previous) {
-    if (target === 'allowBuilds')
-        return ALLOW_BUILDS_LABEL[previous];
-    // a list item is either there or not — denied / pending / other only exist in allowBuilds
-    return previous === 'allowed' ? 'already listed' : 'added to the list';
-}

package/dist/generators/doctor/integration-report.js

@@ -1,70 +0,0 @@
-import { computeOverallStatus } from '@nx-archweave/shared';
-import { runDoctorChecks } from '@nx-archweave/template-engine';
-import { detectIntegrationsDrift, readEnabledIntegrationIds, buildIntegrationDoctorChecks, classifyIntegrationDrift, loadManifest, detectWorkspacePackage, verifyClaudeMarketplacePlugin, PLUGIN_CATALOG, } from '@nx-archweave/integrations';
-import { createIntegrationsCompositionRoot, } from "../../runtime/integrations-composition-root.js";
-import { diskRunNx } from "../shared/run-nx.js";
-// Only claude-code is a supported target for now — doctor
-// does not yet accept a --target option, so this is the one hardcoded value.
-const DOCTOR_TARGET_ENVIRONMENT = 'claude-code';
-export async function buildDoctorReportWithIntegrations(root, options = {}, deps = {}) {
-    const integrationsRoot = deps.integrationsRoot ?? createIntegrationsCompositionRoot();
-    const baseReport = runDoctorChecks(root);
-    const declaredIds = readEnabledIntegrationIds(root);
-    const runNx = diskRunNx(root);
-    const driftResults = await detectIntegrationsDrift({
-        workspaceRoot: root,
-        targetEnvironment: DOCTOR_TARGET_ENVIRONMENT,
-        declaredIds,
-        integrations: integrationsRoot.listIntegrations(),
-        runNx,
-    });
-    // Without --live-integrations: no ReadOnlyCommandRunner call happens at
-    // all — doctor stays fast and available even where the claude CLI is not
-    // installed, trusting the recorded manifest state exactly as before.
-    const finalDriftResults = options.liveIntegrations
-        ? await applyLiveVerification(driftResults, {
-            root,
-            declaredIds,
-            runner: integrationsRoot.runner,
-            runNx,
-        })
-        : driftResults;
-    const integrationChecks = buildIntegrationDoctorChecks(finalDriftResults);
-    const checks = [...baseReport.checks, ...integrationChecks];
-    return { checks, overallStatus: computeOverallStatus(checks) };
-}
-// Re-derives each catalog plugin's drift result using a live verification signal in
-// place of the manifest's frozen `verification` field — every other input to
-// classifyIntegrationDrift (declared, detected) is unchanged, so this never
-// duplicates the classification logic itself, only substitutes one input to
-// it. This is still fully read-only: no manifest or config write, no repair.
-async function applyLiveVerification(driftResults, ctx) {
-    const context = { workspaceRoot: ctx.root, targetEnvironment: DOCTOR_TARGET_ENVIRONMENT };
-    const manifest = loadManifest(ctx.root);
-    const live = new Map();
-    // Only the plugins doctor reports on, and only those this target can verify — each live
-    // check is one `claude plugin list` call.
-    const reported = new Set(driftResults.map((result) => result.id));
-    for (const entry of PLUGIN_CATALOG) {
-        if (!reported.has(entry.id) || entry.hosts[DOCTOR_TARGET_ENVIRONMENT] === undefined)
-            continue;
-        const existingEntry = manifest.integrations[entry.id];
-        const detected = await detectWorkspacePackage(entry, context);
-        const { result: liveVerification } = await verifyClaudeMarketplacePlugin(entry, { runner: ctx.runner }, context);
-        // A stale recorded "passed" must never survive a current live failure —
-        // the live result always wins over the recorded one
-        // when --live-integrations is set, never the other way around.
-        const liveEntry = existingEntry
-            ? { ...existingEntry, verification: liveVerification.verified ? 'passed' : 'failed' }
-            : existingEntry;
-        live.set(entry.id, classifyIntegrationDrift({
-            id: entry.id,
-            installable: true,
-            declared: ctx.declaredIds.includes(entry.id),
-            manifestEntry: liveEntry,
-            detected,
-            runNx: ctx.runNx,
-        }));
-    }
-    return driftResults.map((result) => live.get(result.id) ?? result);
-}

package/dist/generators/doctor/render.js

@@ -1,10 +0,0 @@
-export function renderDoctorReport(report) {
-    const lines = [`Overall status: ${report.overallStatus}`, ''];
-    for (const check of report.checks) {
-        lines.push(`[${check.status.toUpperCase()}] ${check.label}: ${check.message}`);
-        if (check.suggestedAction) {
-            lines.push(`  → ${check.suggestedAction}`);
-        }
-    }
-    return lines.join('\n');
-}

package/dist/generators/init/render.js

@@ -1,125 +0,0 @@
-import { packageManagerCommands } from '@nx-archweave/template-engine';
-import { renderAddFsdLiteReport } from "../add-fsd-lite/render.js";
-import { renderAddAgentRulesReport } from "../add-agent-rules/render.js";
-import { renderAddGithubTemplatesReport } from "../add-github-templates/render.js";
-import { renderAddReviewReport } from "../add-review/render.js";
-import { renderAddBackendBody } from "../add-backend/render.js";
-const SECTION_TITLES = {
-    fsd: 'add-fsd-lite',
-    agentRules: 'add-agent-rules',
-    githubTemplates: 'add-github-templates',
-    review: 'add-review',
-    backend: 'add-backend',
-};
-function renderSectionReport(report) {
-    switch (report.kind) {
-        case 'fsd':
-            return renderAddFsdLiteReport(report.report);
-        case 'agentRules':
-            return renderAddAgentRulesReport(report.report);
-        case 'githubTemplates':
-            return renderAddGithubTemplatesReport(report.report);
-        case 'review':
-            return renderAddReviewReport(report.report);
-        case 'backend':
-            return renderAddBackendBody(report.report);
-    }
-}
-/** Whether a section left the run in a state that only a `git restore .` can cleanly
- * undo — i.e. it aborted outright. Sections that merely proposed/skipped a file (no
- * write happened) do not count: there is nothing of theirs to roll back. */
-function sectionAborted(section) {
-    if (section.thrownError !== undefined)
-        return true;
-    if (section.report === null)
-        return false;
-    if (section.report.kind === 'fsd')
-        return section.report.report.aborted;
-    if (section.report.kind === 'review')
-        return section.report.report.workflowAction === 'aborted';
-    return false;
-}
-export function renderInitReport(report) {
-    const lines = [];
-    const backendSuffix = report.backend === 'none' ? '' : `, backend: ${report.backend}`;
-    const header = `init (preset: ${report.preset}, frontend: ${report.frontend}${backendSuffix})`;
-    lines.push(report.dryRun ? `${header} — dry run` : header);
-    if (report.refused) {
-        lines.push('');
-        lines.push('Refused: the working tree has uncommitted changes.');
-        lines.push('  init only runs against a clean working tree, so a partial run can always be undone');
-        lines.push('  with a single `git restore .` — commit or stash your changes, then rerun.');
-        return lines.join('\n');
-    }
-    for (const section of report.sections) {
-        // backend 'none' must leave the output byte-identical to the frontend-only
-        // era (silence guarantee) — a disabled backend section is omitted
-        // entirely, not shown as skipped.
-        if (section.id === 'backend' && !section.enabled)
-            continue;
-        lines.push('');
-        lines.push(`## ${SECTION_TITLES[section.id]}`);
-        if (!section.enabled) {
-            lines.push(section.id === 'fsd' && report.frontend === 'none'
-                ? '  skipped (backend-only workspace — no frontend to structure)'
-                : '  skipped (disabled for this run)');
-            continue;
-        }
-        if (section.thrownError !== undefined) {
-            lines.push(`  aborted — unexpected error: ${section.thrownError}`);
-            lines.push('  Nothing was written for this section. Rerun add-fsd-lite directly once resolved.');
-            continue;
-        }
-        if (section.report !== null) {
-            lines.push(renderSectionReport(section.report));
-        }
-    }
-    if (report.config !== undefined && (report.config.action !== 'skipped' || report.config.notRecorded.length > 0)) {
-        lines.push('');
-        lines.push('## toolkit.config.json');
-        const fieldList = report.config.fields.join(', ');
-        switch (report.config.action) {
-            case 'created':
-            case 'updated':
-                lines.push(`  ${report.dryRun ? 'would record' : 'recorded'} ${fieldList} (${report.config.action})`);
-                break;
-            case 'unchanged':
-                lines.push(`  already records ${fieldList} (unchanged)`);
-                break;
-            case 'unrecognized':
-                lines.push(`  not updated — the file is not a JSON object, so init left it alone (it never rewrites a shape it`);
-                lines.push(`  does not recognize). Add ${fieldList} by hand so standalone reruns resolve the same values.`);
-                break;
-            case 'skipped':
-                break;
-        }
-        if (report.config.notRecorded.length > 0) {
-            lines.push(`  not recorded: ${report.config.notRecorded.map((n) => n.field).join(', ')} — that section did not apply cleanly`);
-            lines.push('  this run (aborted, or written as an alternate file). Once resolved, record it with:');
-            const runNx = packageManagerCommands(report.packageManager ?? 'pnpm').runNx;
-            for (const entry of report.config.notRecorded)
-                lines.push(`    ${runNx} g @clearlydev/nx-archweave:${entry.rerun}`);
-        }
-    }
-    const ranDirty = report.allowDirty === true && !report.cleanTree && !report.dryRun;
-    if (ranDirty) {
-        lines.push('');
-        lines.push('Note: --allowDirty was set and the working tree already had uncommitted changes —');
-        lines.push('`git restore .` also reverts those pre-existing changes, not only what this run wrote.');
-    }
-    const hadAbort = report.sections.some(sectionAborted);
-    if (!report.dryRun && hadAbort) {
-        lines.push('');
-        if (ranDirty) {
-            lines.push('One or more sections aborted. Everything this run wrote can be undone with:');
-            lines.push('  git restore .');
-            lines.push('  (--allowDirty: this also reverts the pre-existing uncommitted changes noted above.)');
-        }
-        else {
-            lines.push('One or more sections aborted. init never runs against a dirty tree (see above), so everything');
-            lines.push('this run wrote can be undone in one step:');
-            lines.push('  git restore .');
-        }
-    }
-    return lines.join('\n');
-}

package/dist/generators/init/validation.js

@@ -1,74 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { spawnableCommand } from '@nx-archweave/shared';
-export function createProcessExec() {
-    return (command, args, options) => {
-        // nx / actionlint may be .cmd shims on Windows, which Node cannot start without cmd.exe.
-        const spawnable = spawnableCommand(command, args);
-        const result = spawnSync(spawnable.command, spawnable.args, {
-            cwd: options?.cwd,
-            encoding: 'utf-8',
-            windowsVerbatimArguments: spawnable.windowsVerbatimArguments,
-        });
-        return { status: result.status ?? null, stdout: result.stdout ?? '', stderr: result.stderr ?? '' };
-    };
-}
-/** Runs `exec`, catching anything it throws (e.g. a stub or an unforeseen environment
- * failure) so a single check can never take down the rest of validation — the "never
- * throws" half of the best-effort contract applies even to the injected dependency, not
- * just to non-zero exit codes. */
-function safeExec(exec, command, args, options) {
-    try {
-        return exec(command, args, options);
-    }
-    catch (error) {
-        return { status: null, stdout: '', stderr: error instanceof Error ? error.message : String(error) };
-    }
-}
-/** Post-flush, best-effort validation: never throws, only
- * reports via console. Runs after the generator's `GeneratorCallback` fires, once every
- * file this run wrote is actually on disk. Neither actionlint nor nx are added as
- * dependencies — both are invoked as external binaries, detected at call time. */
-export function runPostInitValidation(input, exec) {
-    console.log('');
-    console.log('Post-run validation (best-effort):');
-    if (input.workflowPaths.length === 0) {
-        console.log('  actionlint: skipped (no GitHub Actions workflow files were written this run)');
-    }
-    else {
-        const versionCheck = safeExec(exec, 'actionlint', ['--version'], { cwd: input.root });
-        if (versionCheck.status !== 0) {
-            console.log('  actionlint: not found on PATH — skipped.');
-            console.log('    Install it from https://github.com/rhysd/actionlint to validate workflow files locally.');
-        }
-        else {
-            const lintResult = safeExec(exec, 'actionlint', input.workflowPaths, { cwd: input.root });
-            if (lintResult.status === 0) {
-                console.log(`  actionlint: passed (${input.workflowPaths.join(', ')})`);
-            }
-            else {
-                console.log('  actionlint: reported issues —');
-                for (const line of (lintResult.stdout || lintResult.stderr).split('\n')) {
-                    if (line.length > 0)
-                        console.log(`    ${line}`);
-                }
-            }
-        }
-    }
-    const nxVersionCheck = safeExec(exec, 'nx', ['--version'], { cwd: input.root });
-    if (nxVersionCheck.status !== 0) {
-        console.log('  nx graph: nx not found on PATH — skipped.');
-        console.log('    Run it via your package manager instead, e.g. `pnpm nx graph`, `yarn nx graph`, `bun nx graph` or `npm exec nx graph`.');
-        return;
-    }
-    const graphResult = safeExec(exec, 'nx', ['graph', `--file=${input.graphOutputFile}`], { cwd: input.root });
-    if (graphResult.status === 0) {
-        console.log(`  nx graph: valid (written to ${input.graphOutputFile})`);
-    }
-    else {
-        console.log('  nx graph: failed —');
-        for (const line of (graphResult.stdout || graphResult.stderr).split('\n')) {
-            if (line.length > 0)
-                console.log(`    ${line}`);
-        }
-    }
-}

package/dist/generators/install-integration/render.js

@@ -1,128 +0,0 @@
-function describeState(state) {
-    switch (state.kind) {
-        case 'absent':
-            return 'not installed';
-        case 'already-installed':
-            return `already installed and enabled at ${state.scope} scope${state.version ? ` (version ${state.version})` : ''}`;
-        case 'installed-other-scope':
-            return `installed and enabled, but at ${state.installedScope} scope`;
-        case 'disabled':
-            return 'installed but disabled';
-        case 'ambiguous':
-            return 'more than one installed plugin matches exactly';
-        case 'cli-not-found':
-            return 'unknown — the claude CLI was not found';
-        case 'cli-error':
-            return `unknown — the claude CLI could not list plugins (${state.reason})`;
-    }
-}
-function describeInstall(detail) {
-    switch (detail.kind) {
-        case 'executed':
-            return 'the official command exited successfully';
-        case 'manual-only':
-            return 'no scriptable command exists for this target — nothing was executed';
-        case 'cli-not-found':
-            return 'not executed — the claude CLI was not found';
-        case 'failed-to-start':
-            return `not executed — the claude CLI could not be started (${detail.code})`;
-        case 'cli-unsupported':
-            return 'not executed — this claude CLI does not support scriptable plugin install';
-        case 'confirmation-required':
-            return 'stopped — the marketplace declares a command that a person must confirm';
-        case 'failed':
-            return `failed${detail.failureCode ? ` (${detail.failureCode})` : ''}`;
-        case 'timeout':
-            return 'stopped — the command timed out';
-        case 'output-too-large':
-            return 'stopped — the command produced too much output';
-    }
-}
-function describeDeclaration(declaration, tool, preview) {
-    switch (declaration.action) {
-        case 'updated':
-            return `toolkit.config.json: "${tool}" ${preview ? 'would be added' : 'added'} to integrations.enabled`;
-        case 'unchanged':
-            return `toolkit.config.json: "${tool}" is already declared in integrations.enabled (unchanged)`;
-        case 'no-config':
-            return (`toolkit.config.json: not declared — this workspace has no toolkit.config.json (it was not set up with init). ` +
-                `Add "${tool}" to integrations.enabled there if you want doctor to track the declaration.`);
-        case 'unrecognized':
-            return ('toolkit.config.json: not updated — the file is not in a shape nx-archweave recognizes, so it was left alone. ' +
-                `Add "${tool}" to integrations.enabled by hand.`);
-        case 'write-failed':
-            return `toolkit.config.json: not updated — writing it failed (${declaration.message}). Add "${tool}" to integrations.enabled by hand.`;
-    }
-}
-// Every value here is a tool id, a URL, a command, a classification, a manifest
-// entry (installPath excluded by construction) or a
-// CLI message that was home-path-redacted where it was produced (install.ts).
-export function renderInstallIntegrationView(view) {
-    const lines = [
-        `Integration: ${view.tool} (a separate project — nx-archweave only runs its official installer)`,
-        `Source repository: ${view.sourceRepository}`,
-        `Official homepage: ${view.officialHomepage}`,
-        `License: ${view.license}`,
-        view.requestedVersion === null
-            ? 'Version: latest (decided by the marketplace) — the version actually installed is the one recorded'
-            : `Requested version: ${view.requestedVersion} (not enforced — the marketplace decides; the version actually installed is the one recorded)`,
-        `Target: ${view.target}`,
-        `Scope: ${view.scope}`,
-        `Official command: ${view.command}`,
-        ...(view.teamMarketplace
-            ? [`For teammates (project scope), the marketplace is declared in .claude/settings.json first: ${view.teamMarketplace.command}`]
-            : []),
-        ...(view.workspaceFiles.length > 0 ? [`Claude Code will update in this workspace: ${view.workspaceFiles.join(', ')}`] : []),
-        `Current state: ${describeState(view.currentState)}`,
-    ];
-    if (view.applyIgnoredForNxDryRun) {
-        lines.push("Note: --apply was ignored because Nx's --dry-run is set.");
-    }
-    if (view.preview && view.currentState.kind === 'absent') {
-        lines.push('', ...(view.teamMarketplace ? [`Would run: ${view.teamMarketplace.command}`] : []), `Would run: ${view.command}`, `To run it: ${view.rerunCommand}`);
-    }
-    else if (view.preview && view.teamMarketplace) {
-        lines.push('', `Would run: ${view.teamMarketplace.command}`, `To run it: ${view.rerunCommand}`);
-    }
-    if (view.teamMarketplace?.detail) {
-        const { detail } = view.teamMarketplace;
-        lines.push('', detail.kind === 'executed'
-            ? 'Marketplace: declared in .claude/settings.json (extraKnownMarketplaces) — teammates get its source from the committed file'
-            : `Marketplace declaration: ${describeInstall(detail)}${detail.kind === 'failed' ? ` — ${detail.message}` : ''}`);
-    }
-    if (view.install) {
-        lines.push('', `Install: ${describeInstall(view.install.detail)}`);
-    }
-    if (view.record) {
-        const { record } = view;
-        lines.push('', `Verification: ${record.verification.verified ? 'passed' : 'not verified'}`, ...record.verification.problems.map((problem) => `  ! ${problem}`));
-        if (record.hasConflict && record.existingEntry) {
-            lines.push('Conflict: an existing manifest entry differs from what was verified now — the fresh result replaces it.', `  Existing: ${JSON.stringify(record.existingEntry)}`, `  Verified: ${JSON.stringify(record.proposedEntry)}`);
-        }
-        const installKind = view.install?.detail.kind;
-        if (record.proposedEntry) {
-            if (installKind !== undefined && installKind !== 'executed') {
-                lines.push(`The install command reported ${installKind}, but a fresh check shows the plugin installed and enabled.`);
-            }
-            lines.push(record.wasWritten
-                ? 'Recorded — the following manifest entry was written to archweave-integrations.json:'
-                : 'archweave-integrations.json would get this entry:', `  ${JSON.stringify(record.proposedEntry)}`);
-        }
-        else if (installKind === 'executed') {
-            lines.push('The install command exited 0, but the fresh verification did not confirm the plugin — nothing was written.');
-        }
-        else {
-            lines.push('Nothing was written — verification did not succeed via the authoritative claude-cli signal.');
-        }
-    }
-    if (view.declaration) {
-        lines.push(describeDeclaration(view.declaration, view.tool, view.preview));
-    }
-    if (view.guidance.length > 0) {
-        lines.push('', 'Next steps:', ...view.guidance.map((step) => `  - ${step}`));
-    }
-    lines.push('', view.preview
-        ? '(preview — only read-only checks ran; nothing was installed and no file was written)'
-        : '(applied — the lines above state exactly what was executed and written)');
-    return lines.join('\n');
-}

package/dist/generators/record-integration/render.js

@@ -1,31 +0,0 @@
-// Never renders installPath or any absolute/home-directory path — the
-// manifest entry types used here already exclude installPath by
-// construction, and this function only ever reads from
-// those already-narrowed values.
-export function renderRecordIntegrationView(view) {
-    const lines = [
-        `Integration: ${view.tool}`,
-        `Target: ${view.target}`,
-        `Source repository: ${view.sourceRepository}`,
-        `License: ${view.license}`,
-        `Verification source: ${view.verificationSource}`,
-        `Current verification: ${view.verification.verified ? 'passed' : 'not verified'}`,
-        ...view.verification.problems.map((problem) => `  ! ${problem}`),
-        '',
-    ];
-    if (view.hasConflict && view.existingEntry) {
-        lines.push('Conflict: an existing manifest entry differs from what would be recorded.', `  Existing: ${JSON.stringify(view.existingEntry)}`, `  Proposed: ${JSON.stringify(view.proposedEntry)}`, '');
-    }
-    if (view.proposedEntry) {
-        lines.push(view.wasWritten
-            ? 'Recorded — the following manifest entry was written:'
-            : 'The following manifest entry would be recorded:', `  ${JSON.stringify(view.proposedEntry)}`);
-    }
-    else {
-        lines.push('Nothing would be recorded — verification did not succeed via the authoritative claude-cli signal.');
-    }
-    lines.push('', view.wasWritten
-        ? '(recorded — the manifest was written)'
-        : '(dry-run — no files were changed, no installer was executed, manifest was not written)');
-    return lines.join('\n');
-}

package/dist/generators/shared/dry-run.js

@@ -1,12 +0,0 @@
-/**
- * `nx g` owns the dry-run flag: Nx 23.1's generate command deletes `dryRun` /
- * `dry-run` from the options it hands a generator and then refills the schema
- * default, and signals its own `--dry-run` only through `NX_DRY_RUN=true`
- * (`nx/src/command-line/generate/generate.js`, `command-object.js`). So an Nx
- * entry point that read only `options.dryRun` would always see `false` and print
- * "created" for a run Nx never flushes. Programmatic callers (init → the `run*`
- * cores, tests) keep passing `dryRun` explicitly; Nx's own flag always wins.
- */
-export function resolveDryRun(options) {
-    return process.env['NX_DRY_RUN'] === 'true' || (options.dryRun ?? false);
-}

package/dist/generators/shared/frontend-app.js

@@ -1,57 +0,0 @@
-import { getProjects } from '@nx/devkit';
-import { resolveProjectType } from "./project-type.js";
-const baseNameOf = (root) => root.split('/').pop() ?? root;
-function isEndToEnd(root) {
-    const dir = baseNameOf(root);
-    return dir === 'e2e' || dir.endsWith('-e2e');
-}
-/** add-backend's api app (default name `api`) and anything tagged as the backend scope are
- * applications, but not frontends. */
-function isBackend(root, config) {
-    return baseNameOf(root) === 'api' || (config.tags ?? []).includes('scope:backend');
-}
-function sourceRootOf(config) {
-    if (config.sourceRoot)
-        return config.sourceRoot;
-    return config.root === '' || config.root === '.' ? 'src' : `${config.root}/src`;
-}
-/**
- * Same two tiers as add-backend's frontend lookup: declared applications first; only when
- * there are none do undeclared projects count, typed the way Nx infers them (Nx's Next.js
- * and classic-preset apps are bare package.json projects). A declared root application
- * (a standalone workspace, root `.`) counts; an undeclared root package.json never does.
- */
-export function resolveFrontendApp(tree, explicitProject) {
-    let projects;
-    try {
-        projects = getProjects(tree);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        const pathMatch = /Cannot parse ([^:]+):/.exec(message);
-        return { kind: 'invalid-project-json', detail: pathMatch ? pathMatch[1] : message };
-    }
-    const found = (project, config) => ({
-        kind: 'found',
-        project,
-        root: config.root,
-        sourceRoot: sourceRootOf(config),
-    });
-    if (explicitProject !== undefined) {
-        const config = projects.get(explicitProject);
-        return config ? found(explicitProject, config) : { kind: 'not-found', project: explicitProject };
-    }
-    const eligible = [...projects.entries()].filter(([, config]) => !isEndToEnd(config.root) && !isBackend(config.root, config));
-    const declared = eligible.filter(([, config]) => config.projectType === 'application');
-    const inferred = eligible.filter(([, config]) => config.projectType === undefined &&
-        config.root !== '' &&
-        config.root !== '.' &&
-        resolveProjectType(tree, config.root, undefined) === 'application');
-    const candidates = (declared.length > 0 ? declared : inferred).sort(([a], [b]) => a.localeCompare(b));
-    if (candidates.length === 0)
-        return { kind: 'none' };
-    if (candidates.length > 1)
-        return { kind: 'ambiguous', candidates: candidates.map(([name]) => name) };
-    const [project, config] = candidates[0];
-    return found(project, config);
-}

package/dist/generators/shared/project-type.js

@@ -1,39 +0,0 @@
-import { parseJson } from '@nx/devkit';
-/**
- * The project type Nx itself would use when a project declares none — the
- * classic-preset Nx 23 layout configures apps through a bare package.json, so a
- * filter on the declared `projectType` alone misses every one of them.
- *
- * Mirrors the project graph's rule (nx 23 core `normalize-project-nodes`
- * `getProjectType`): a declared type wins (anything but `library` counts as an
- * application, as in Nx); then `tsconfig.lib.json` → library; `tsconfig.app.json`
- * → application; a readable package.json with none of exports/main/module/bin
- * set → application; anything else — including a missing or unparseable
- * package.json — → library. Mirrored, not imported: the plugin's only runtime
- * dependency stays @nx/devkit. Not mirrored: the package-json plugin's
- * `workspaceLayout.appsDir`/`libsDir` override, which devkit's tree-based
- * `getProjects` never applies either.
- */
-export function resolveProjectType(tree, root, declared) {
-    if (declared)
-        return declared === 'library' ? 'library' : 'application';
-    const prefix = root === '' || root === '.' ? '' : `${root}/`;
-    if (tree.exists(`${prefix}tsconfig.lib.json`))
-        return 'library';
-    if (tree.exists(`${prefix}tsconfig.app.json`))
-        return 'application';
-    const raw = tree.read(`${prefix}package.json`, 'utf-8');
-    if (raw === null)
-        return 'library';
-    try {
-        // parseJson accepts comments and trailing commas, like Nx's readJsonFile
-        const manifest = parseJson(raw);
-        // truthiness, like Nx: an empty "main": "" is no entry point
-        if (manifest && !['exports', 'main', 'module', 'bin'].some((key) => Boolean(manifest[key])))
-            return 'application';
-    }
-    catch {
-        // unparseable — Nx's graph falls through to library as well
-    }
-    return 'library';
-}