@clearlydev/nx-archweave 0.1.1 → 0.2.1

package/dist/generators/shared/record-pipeline.js

@@ -1,34 +0,0 @@
-import { buildRecordPlan, getCatalogEntry, loadManifest, recordMetadataFor, verifyClaudeMarketplacePlugin, writeManifestAtomic, } from '@nx-archweave/integrations';
-/**
- * Live verify → manifest record, shared by record-integration and install-integration.
- * Always a fresh call — never a cached result. Only a
- * claude-cli-sourced verified:true is recordable (buildRecordPlan enforces it); the write
- * is the atomic manifest write and happens only when `write` is set.
- */
-export async function runRecordPipeline(input) {
-    const entry = getCatalogEntry(input.id);
-    // Where it came from comes from the catalog entry.
-    const metadata = entry === undefined ? undefined : recordMetadataFor(entry);
-    if (!entry || !metadata) {
-        throw new Error(`No manifest metadata is defined for "${input.id}".`);
-    }
-    const { result: verification, source: verificationSource } = await verifyClaudeMarketplacePlugin(entry, { runner: input.runner }, { workspaceRoot: input.workspaceRoot, targetEnvironment: input.target });
-    const manifest = loadManifest(input.workspaceRoot);
-    const existingEntry = manifest.integrations[input.id];
-    const plan = buildRecordPlan({ id: input.id, target: input.target, verificationSource, verification, existingEntry, metadata });
-    let wasWritten = false;
-    if (input.write && plan.proposedEntry) {
-        writeManifestAtomic(input.workspaceRoot, {
-            integrations: { ...manifest.integrations, [input.id]: plan.proposedEntry },
-        });
-        wasWritten = true;
-    }
-    return {
-        verificationSource,
-        verification,
-        existingEntry,
-        proposedEntry: plan.proposedEntry,
-        hasConflict: plan.hasConflict,
-        wasWritten,
-    };
-}

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

@@ -1,24 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { packageManagerCommands } from '@nx-archweave/template-engine';
-import { TOOLKIT_CONFIG_PATH, workspacePackageManager } from "./toolkit-config-file.js";
-/** How a person runs the workspace's own nx — `pnpm nx`, `yarn nx`, `bun nx` or
- * `npm exec nx --` — for the commands generators print. The detected package manager, then
- * the one init recorded, else pnpm (the same order init, add-backend and add-review use). */
-export function runNxFor(exists, read) {
-    let config = null;
-    try {
-        const parsed = JSON.parse(read(TOOLKIT_CONFIG_PATH) ?? 'null');
-        if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed))
-            config = parsed;
-    }
-    catch {
-        // an unreadable config only means nothing is recorded
-    }
-    return packageManagerCommands(workspacePackageManager(exists, read, config) ?? 'pnpm').runNx;
-}
-/** From the workspace on disk — doctor and the integration generators, which act on the
- * real workspace (tree.root) rather than the Nx Tree. */
-export function diskRunNx(root) {
-    return runNxFor((path) => existsSync(join(root, path)), (path) => (existsSync(join(root, path)) ? readFileSync(join(root, path), 'utf-8') : undefined));
-}

package/dist/generators/shared/template-files.js

@@ -1,38 +0,0 @@
-import { existsSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { generateFiles } from '@nx/devkit';
-// createTree is the devkit's in-memory Tree; it holds the rendered files until the caller has
-// compared each one with the workspace.
-import { createTree } from '@nx/devkit/testing';
-/**
- * The `files/` directory of a generator. `fromUrl` is the calling module's `import.meta.url`:
- * from source and from a generator's own bundle that is `../<generator>/files`; from a bundle
- * that inlines another generator (init runs add-github-templates) the sibling directory is
- * the same, and from the package's root `index.js` it is `./generators/<generator>/files`.
- */
-export function generatorFilesDir(generator, fromUrl) {
-    for (const relative of [`../${generator}/files`, `./generators/${generator}/files`]) {
-        const dir = fileURLToPath(new URL(relative, fromUrl));
-        if (existsSync(dir))
-            return dir;
-    }
-    throw new Error(`The "${generator}" generator's template files are missing next to ${fileURLToPath(fromUrl)}`);
-}
-/**
- * Renders a template folder the way every Nx generator does — `generateFiles`: `__key__` in
- * paths and EJS in contents take the substitutions, a `.template` suffix is dropped — into a
- * scratch tree, and returns the files sorted by path. The caller decides what reaches the
- * workspace (create, leave an existing file alone, or only report it in a dry run).
- */
-export function renderTemplateFiles(srcFolder, target, substitutions) {
-    const scratch = createTree();
-    // createTree seeds a .prettierrc; only what generateFiles adds belongs to the result.
-    const seeded = new Set(scratch.listChanges().map((change) => change.path));
-    generateFiles(scratch, srcFolder, target, substitutions);
-    return scratch
-        .listChanges()
-        .flatMap((change) => change.type === 'CREATE' && change.content !== null && !seeded.has(change.path)
-        ? [{ filePath: change.path, content: change.content.toString('utf-8') }]
-        : [])
-        .sort((a, b) => a.filePath.localeCompare(b.filePath));
-}

package/dist/generators/shared/toolkit-config-file.js

@@ -1,110 +0,0 @@
-import { DEFAULT_AI_HOSTS, detectWorkspacePackageManager, isAiHost } from '@nx-archweave/template-engine';
-export const TOOLKIT_CONFIG_PATH = 'toolkit.config.json';
-/** The indentation unit an existing JSON file uses, so an update preserves the
- * author's formatting: the first indented line's leading run of tabs or spaces,
- * else two spaces (e.g. minified JSON or no file). */
-export function detectIndent(raw) {
-    for (const line of raw.split('\n')) {
-        const match = /^(\t+| +)/.exec(line);
-        if (match)
-            return match[1];
-    }
-    return '  ';
-}
-/** Best-effort read of toolkit.config.json. Never throws: the generators that read
- * defaults from it (locale, boundaries, teamRules) must not abort on a broken file
- * they do not own, and the ones that merge into it refuse to rewrite an
- * unrecognized shape — both decide from this one result. */
-export function readToolkitConfigFile(tree) {
-    const raw = tree.read(TOOLKIT_CONFIG_PATH, 'utf-8');
-    if (raw === null)
-        return { raw: null, parsed: null };
-    try {
-        const parsed = JSON.parse(raw);
-        return {
-            raw,
-            parsed: typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed) ? parsed : null,
-        };
-    }
-    catch {
-        return { raw, parsed: null };
-    }
-}
-/** The parsed object only — for readers that just want defaults. */
-export function readToolkitConfig(tree) {
-    return readToolkitConfigFile(tree).parsed;
-}
-/** option > toolkit.config.json `locale` > 'en' — the fallback every content
- * generator shares; anything that is not ko/en is ignored, never an abort. */
-export function resolveLocaleOption(option, config) {
-    if (option)
-        return option;
-    const locale = config?.['locale'];
-    return locale === 'ko' || locale === 'en' ? locale : 'en';
-}
-/** A recorded choice init wrote, when it is one of `allowed`; anything else is ignored. */
-export function recordedChoice(config, key, allowed) {
-    const value = config?.[key];
-    return typeof value === 'string' && allowed.includes(value) ? value : undefined;
-}
-export const RECORDED_FRONTENDS = ['react-vite', 'next', 'none'];
-export const RECORDED_BACKENDS = ['express', 'nest', 'none'];
-export const RECORDED_PRESETS = ['quick-start', 'solo', 'team'];
-export const RECORDED_PACKAGE_MANAGERS = ['pnpm', 'npm', 'yarn', 'bun'];
-/** option > toolkit.config.json `frontend` (init records it); a run without either cannot
- * pick the layer set, so it stops with the flag to pass. A backend-only workspace
- * (`frontend: none`) has no frontend to structure, which stops the FSD generators too. */
-export function resolveFrontendOption(option, config, generator) {
-    const frontend = option ?? recordedChoice(config, 'frontend', RECORDED_FRONTENDS);
-    if (frontend === undefined) {
-        throw new Error(`${generator}: pass --frontend=react-vite|next (toolkit.config.json records none — init writes it).`);
-    }
-    if (frontend === 'none') {
-        throw new Error(`${generator}: this is a backend-only workspace (toolkit.config.json frontend: none) — FSD structures a frontend app. Pass --frontend=react-vite|next if you added one.`);
-    }
-    return frontend;
-}
-/** init's frontend axis: like resolveFrontendOption, but `none` (backend-only) is a choice. */
-export function resolveInitFrontend(option, config) {
-    const frontend = option ?? recordedChoice(config, 'frontend', RECORDED_FRONTENDS);
-    if (frontend === undefined) {
-        throw new Error('init: pass --frontend=react-vite|next|none (toolkit.config.json records none — init writes it).');
-    }
-    return frontend;
-}
-/** The workspace's package manager: its lockfiles first (they are what installs run with,
- * even after a switch), then the one init recorded; null when neither says. */
-export function workspacePackageManager(exists, read, config) {
-    return detectWorkspacePackageManager(exists, read) ?? recordedChoice(config, 'packageManager', RECORDED_PACKAGE_MANAGERS) ?? null;
-}
-export function treePackageManager(tree, config) {
-    return workspacePackageManager((p) => tree.exists(p), (p) => tree.read(p, 'utf-8'), config);
-}
-/** Option (non-empty, deduped) > toolkit.config.json `aiHosts`
- * (its known ids) > Claude Code. Shared by add-agent-rules and init, so a standalone run of
- * either keeps the hosts a workspace was set up for. */
-export function resolveAiHostsOption(option, config) {
-    if (option !== undefined && option.length > 0)
-        return [...new Set(option)];
-    const recorded = config?.['aiHosts'];
-    const fromConfig = Array.isArray(recorded) ? [...new Set(recorded.filter(isAiHost))] : [];
-    return fromConfig.length > 0 ? fromConfig : [...DEFAULT_AI_HOSTS];
-}
-/** Writes `aiHosts` into toolkit.config.json: merge-preserving (every other key survives),
- * indent-preserving, idempotent; a file that is not a JSON object is never rewritten. */
-export function recordAiHosts(tree, hosts, write) {
-    const { raw, parsed } = readToolkitConfigFile(tree);
-    if (raw !== null && parsed === null)
-        return 'unrecognized';
-    const existing = parsed ?? {};
-    const recorded = existing['aiHosts'];
-    if (Array.isArray(recorded) && recorded.length === hosts.length && recorded.every((id, index) => id === hosts[index])) {
-        return 'unchanged';
-    }
-    if (write) {
-        const indent = raw === null ? '  ' : detectIndent(raw);
-        const body = JSON.stringify({ ...existing, aiHosts: [...hosts] }, null, indent);
-        tree.write(TOOLKIT_CONFIG_PATH, raw === null || raw.endsWith('\n') ? `${body}\n` : body);
-    }
-    return raw === null ? 'created' : 'updated';
-}

package/dist/generators/slice/core.js

@@ -1,185 +0,0 @@
-import { join } from 'node:path';
-import { isEssenceSegmentName, isUsableSliceApiName, resolveSlicePublicApiName, SEGMENT_NAME_PATTERN, } from '@nx-archweave/template-engine';
-import { readToolkitConfig, RECORDED_FRONTENDS, resolveLocaleOption } from "../shared/toolkit-config-file.js";
-import { resolveFrontendApp } from "../shared/frontend-app.js";
-import { generatorFilesDir, renderTemplateFiles } from "../shared/template-files.js";
-/**
- * A slice on a sliced layer, from this generator's `files/`:
- *   <src>/<layer>/<name>/index.ts             public API          (files/index)
- *   <src>/<layer>/<name>/model/<name>.ts      the stub            (files/module)
- *   <src>/<layer>/<name>/model/<name>.spec.ts
- *   <src>/<layer>/<name>/<segment>/index.ts   per --segments      (files/segment)
- * A shared segment holds no segments of its own, so its stub sits next to the index.
- */
-export function composeSlice(input) {
-    const files = generatorFilesDir('slice', import.meta.url);
-    const directory = `${input.sourceRoot}/${input.layerDirName}/${input.name}`;
-    const shared = input.layer === 'shared';
-    const values = {
-        name: input.name,
-        publicApiName: input.publicApiName,
-        layer: input.layer,
-        locale: input.locale,
-        modulePath: shared ? `./${input.name}` : `./model/${input.name}`,
-    };
-    const module = renderTemplateFiles(join(files, 'module'), shared ? directory : `${directory}/model`, values)
-        // the stub before its test
-        .sort((a, b) => Number(a.filePath.endsWith('.spec.ts')) - Number(b.filePath.endsWith('.spec.ts')));
-    const segments = shared
-        ? []
-        : Array.from(new Set(input.segments))
-            .filter((segment) => segment !== 'model')
-            .flatMap((segment) => renderTemplateFiles(join(files, 'segment'), `${directory}/${segment}`, { ...values, segment }));
-    return {
-        directory,
-        publicApiName: input.publicApiName,
-        files: [...renderTemplateFiles(join(files, 'index'), directory, values), ...module, ...segments],
-    };
-}
-/** Lowercase letters/digits, single hyphens, no leading/trailing/doubled hyphen, must
- * start with a letter (so `toCamelCase`/directory names stay valid identifiers). */
-const KEBAB_CASE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
-/** Next.js reads `src/pages` as its Pages Router, so FSD's Next.js guide puts the pages
- * layer in `_pages/` there (as add-fsd-lite's guide says). Every other layer is its id. */
-function layerDirNameFor(layer, frontend) {
-    return layer === 'pages' && frontend === 'next' ? '_pages' : layer;
-}
-function layerDirFor(layer, sourceRoot, frontend = 'react-vite') {
-    return `${sourceRoot}/${layerDirNameFor(layer, frontend)}`;
-}
-const NEXT_CONFIG_FILES = ['next.config.js', 'next.config.mjs', 'next.config.ts', 'next.config.cjs'];
-/** option > toolkit.config.json's frontend (init records it) > a next.config file in the app
- * (Nx's Next.js app always has one) > react-vite. Best-effort: it only moves `pages` to
- * `_pages`, so a wrong guess costs a rename, never a broken file. */
-function resolveFrontendForApp(option, config, appRoot, tree) {
-    if (option === 'react-vite' || option === 'next')
-        return option;
-    const recorded = config?.['frontend'];
-    if (typeof recorded === 'string' && RECORDED_FRONTENDS.includes(recorded) && recorded !== 'none') {
-        return recorded;
-    }
-    const prefix = appRoot === '' || appRoot === '.' ? '' : `${appRoot}/`;
-    return NEXT_CONFIG_FILES.some((file) => tree.exists(`${prefix}${file}`)) ? 'next' : 'react-vite';
-}
-/** A slice directory is:
- * - 'created' when it doesn't exist yet;
- * - 'unchanged' when it exists and contains exactly our generated files, byte-for-byte;
- * - 'skipped' for anything else (same-name slice already there with different/extra
- *   content — a name collision is a signal to pick a new name; merge is never proposed). */
-/** Every file under `dir`, as paths relative to it (the generated set spans model/). */
-function listFilesUnder(tree, dir, prefix = '') {
-    return tree.children(dir).flatMap((child) => {
-        const path = `${dir}/${child}`;
-        return tree.isFile(path) ? [`${prefix}${child}`] : listFilesUnder(tree, path, `${prefix}${child}/`);
-    });
-}
-function computeSliceAction(tree, plan) {
-    if (!tree.exists(plan.directory))
-        return 'created';
-    const expectedNames = plan.files.map((f) => f.filePath.slice(plan.directory.length + 1)).sort();
-    const actualNames = listFilesUnder(tree, plan.directory).sort();
-    if (actualNames.length !== expectedNames.length || !actualNames.every((n, i) => n === expectedNames[i])) {
-        return 'skipped';
-    }
-    const allMatch = plan.files.every((f) => tree.read(f.filePath, 'utf-8') === f.content);
-    return allMatch ? 'unchanged' : 'skipped';
-}
-function refusal(reason, dryRun, layer, name, app, extra = {}) {
-    const layerDir = layerDirFor(layer, app.sourceRoot);
-    return {
-        dryRun,
-        layer,
-        name,
-        project: app.project,
-        layerDir,
-        directory: `${layerDir}/${name}`,
-        publicApiName: null,
-        refused: true,
-        refusalReason: reason,
-        action: null,
-        files: [],
-        ...extra,
-    };
-}
-/**
- * Pure core shared by the `page` / `widget` / `feature` / `entity` / `shared` generators.
- * `layer` is fixed per top-level generator — only the option parsing, tree reads, and
- * report shape are shared here.
- *
- * The layer directory (`<app sourceRoot>/<layer>`) appears with its first slice (canonical
- * FSD) — nothing has to exist beforehand but the frontend app.
- */
-export function runFsdSlice(tree, layer, options) {
-    const dryRun = options.dryRun ?? false;
-    // Placeholder location for refusals raised before an app is picked.
-    const unresolved = { project: null, sourceRoot: '<app>/src' };
-    if (!KEBAB_CASE.test(options.name)) {
-        return refusal('invalid-name', dryRun, layer, options.name, unresolved);
-    }
-    // Validate the SAME effective value the composer will embed — an explicit
-    // publicApiName that isn't an identifier, or a slice name whose camelCase
-    // default is a reserved word (e.g. "class", "delete"), would otherwise
-    // silently produce syntactically broken TypeScript.
-    if (!isUsableSliceApiName(resolveSlicePublicApiName(options.name, options.publicApiName))) {
-        return refusal('invalid-public-api-name', dryRun, layer, options.name, unresolved);
-    }
-    // canonical FSD: a shared segment is named by purpose (ui, api, model, lib, config), never
-    // by what it contains.
-    if (layer === 'shared' && isEssenceSegmentName(options.name)) {
-        return refusal('segment-by-essence', dryRun, layer, options.name, unresolved);
-    }
-    // --segments: a shared segment holds no segments; elsewhere each
-    // name must be a directory-safe name by purpose, like the shared generator's own names.
-    const segments = Array.from(new Set(options.segments ?? []));
-    if (segments.length > 0 && layer === 'shared') {
-        return refusal('segments-on-shared', dryRun, layer, options.name, unresolved);
-    }
-    const badSegment = segments.find((segment) => !SEGMENT_NAME_PATTERN.test(segment));
-    if (badSegment !== undefined)
-        return refusal('invalid-segment', dryRun, layer, options.name, unresolved, { detail: badSegment });
-    const essenceSegment = segments.find((segment) => isEssenceSegmentName(segment));
-    if (essenceSegment !== undefined)
-        return refusal('segment-by-essence', dryRun, layer, options.name, unresolved, { detail: essenceSegment });
-    const app = resolveFrontendApp(tree, options.project);
-    if (app.kind === 'not-found')
-        return refusal('project-not-found', dryRun, layer, options.name, { project: app.project, sourceRoot: unresolved.sourceRoot });
-    if (app.kind === 'ambiguous')
-        return refusal('ambiguous-frontend', dryRun, layer, options.name, unresolved, { candidates: app.candidates });
-    if (app.kind === 'invalid-project-json')
-        return refusal('invalid-project-json', dryRun, layer, options.name, unresolved, { detail: app.detail });
-    if (app.kind === 'none')
-        return refusal('no-frontend-app', dryRun, layer, options.name, unresolved);
-    // The layer directory is created with its first slice (canonical FSD) — add-fsd-lite makes
-    // no folders. tree.write creates every missing parent.
-    const config = readToolkitConfig(tree);
-    const frontend = resolveFrontendForApp(options.frontend, config, app.root, tree);
-    const layerDir = layerDirFor(layer, app.sourceRoot, frontend);
-    const locale = resolveLocaleOption(options.locale, config);
-    const plan = composeSlice({
-        layer,
-        name: options.name,
-        publicApiName: resolveSlicePublicApiName(options.name, options.publicApiName),
-        locale,
-        sourceRoot: app.sourceRoot,
-        layerDirName: layerDirNameFor(layer, frontend),
-        segments,
-    });
-    const action = computeSliceAction(tree, plan);
-    if (action === 'created' && !dryRun) {
-        for (const file of plan.files)
-            tree.write(file.filePath, file.content);
-    }
-    return {
-        dryRun,
-        layer,
-        name: options.name,
-        project: app.project,
-        layerDir,
-        directory: plan.directory,
-        publicApiName: plan.publicApiName,
-        refused: false,
-        refusalReason: null,
-        action,
-        files: plan.files,
-    };
-}

package/dist/generators/slice/render.js

@@ -1,70 +0,0 @@
-const ACTION_LINES = {
-    created: 'created',
-    unchanged: 'unchanged (already matches the generated content)',
-    skipped: 'skipped — a slice with this name already exists with different content',
-};
-export function renderSliceReport(report) {
-    const lines = [];
-    const label = `${report.layer} "${report.name}"`;
-    if (report.refused) {
-        lines.push(`${label}: refused — nothing was written.`);
-        lines.push('');
-        if (report.refusalReason === 'invalid-name') {
-            lines.push(`  "${report.name}" is not a valid kebab-case slice name.`);
-            lines.push('  Use lowercase letters, digits, and single hyphens, starting with a letter (e.g. "add-to-cart").');
-        }
-        else if (report.refusalReason === 'invalid-public-api-name') {
-            lines.push('  The public API name is not a usable JavaScript identifier (or is a reserved word).');
-            lines.push('  Pass --publicApiName with a valid identifier, e.g. "addToCart" (this also happens when');
-            lines.push('  the slice name camelCases into a reserved word, like "class" or "delete").');
-        }
-        else if (report.refusalReason === 'project-not-found') {
-            lines.push(`  --project=${report.project} names no project in this workspace.`);
-        }
-        else if (report.refusalReason === 'ambiguous-frontend') {
-            lines.push('  More than one frontend app was found — rerun with --project=<one of them>:');
-            for (const name of report.candidates ?? [])
-                lines.push(`    - ${name}`);
-        }
-        else if (report.refusalReason === 'invalid-project-json') {
-            lines.push(`  A project.json could not be parsed (${report.detail ?? 'unknown'}) — fix it, then rerun.`);
-        }
-        else if (report.refusalReason === 'no-frontend-app') {
-            lines.push('  The workspace has no frontend application to hold FSD layers — create one, or pass --project.');
-        }
-        else if (report.refusalReason === 'invalid-segment') {
-            lines.push(`  --segments: "${report.detail ?? ''}" is not a valid segment name.`);
-            lines.push('  Use lowercase letters, digits, and single hyphens, starting with a letter (e.g. ui, api, lib).');
-        }
-        else if (report.refusalReason === 'segments-on-shared') {
-            lines.push('  --segments does not apply to shared: a shared segment holds no segments of its own.');
-            lines.push('  Run the generator once per segment instead (e.g. --name=ui, then --name=api).');
-        }
-        else {
-            const offender = report.detail ?? report.name;
-            lines.push(`  "${offender}" names what a segment contains, not what it is for.`);
-            lines.push('  Canonical FSD names segments by purpose — ui, api, model, lib, config — so the code stays');
-            lines.push('  findable by what it does (e.g. a date helper lives in shared/lib, a Button in shared/ui).');
-        }
-        return lines.join('\n');
-    }
-    if (report.dryRun) {
-        lines.push('dry-run — no files were written.');
-        lines.push('');
-    }
-    lines.push(`${label}: ${ACTION_LINES[report.action]}`);
-    if (report.action === 'skipped') {
-        lines.push(`  ${report.directory} already exists and does not exactly match the generated content.`);
-        lines.push('  Pick a new slice name (a name collision is a signal to rename, not to merge)');
-        lines.push('  — or remove the existing directory manually first if you intended to replace it.');
-        return lines.join('\n');
-    }
-    if (report.dryRun) {
-        for (const file of report.files) {
-            lines.push('');
-            lines.push(`${file.filePath}:`);
-            lines.push(file.content);
-        }
-    }
-    return lines.join('\n');
-}

package/dist/lib/nx-plugin.js

@@ -1,7 +0,0 @@
-import { describeEngine } from '@nx-archweave/template-engine';
-import { createIntegrationsCompositionRoot } from "../runtime/integrations-composition-root.js";
-export function describePlugin() {
-    // Constructing the composition root only counts registered integrations —
-    // it never invokes the runner (no verify() call happens here).
-    return `nx-plugin(${describeEngine()}, integrations=${createIntegrationsCompositionRoot().listIntegrations().length})`;
-}

package/dist/runtime/integrations-composition-root.js

@@ -1,20 +0,0 @@
-import { createCatalogIntegrations, createIntegrationRegistry, getIntegration as getIntegrationFromRegistry, listIntegrations as listIntegrationsFromRegistry, } from '@nx-archweave/integrations';
-import { NodeCommandRunner } from "./node-command-runner.js";
-// The single place every generator (doctor, add-integration,
-// record-integration) obtains its ToolIntegration objects from — never a
-// package-level singleton (factory-based
-// construction). Each call constructs a fresh registry; there is no shared,
-// mutated module state between calls. Defaults to the real, Node-backed
-// runner; tests inject a fake one. The tool list is the plugin catalog (data, in
-// @nx-archweave/integrations); the generators' --tool/--target schema enums are kept
-// equal to it by a test (catalog-schema-enums.spec.ts).
-export function createIntegrationsCompositionRoot(deps = {}) {
-    const runner = deps.runner ?? new NodeCommandRunner();
-    const registry = createIntegrationRegistry(createCatalogIntegrations({ runner }));
-    return {
-        registry,
-        runner,
-        getIntegration: (id) => getIntegrationFromRegistry(registry, id),
-        listIntegrations: () => listIntegrationsFromRegistry(registry),
-    };
-}

package/dist/runtime/node-command-runner.js

@@ -1,81 +0,0 @@
-import { spawn } from 'node:child_process';
-import { spawnableCommand } from '@nx-archweave/shared';
-// SIGTERM is not guaranteed to actually end a process — a child that traps
-// or ignores it would otherwise keep this runner's promise pending forever,
-// silently defeating the fixed timeout/output-limit guarantees. SIGKILL
-// cannot be caught or ignored, so it is the backstop once a process has had
-// a short grace period to exit cleanly on its own.
-const KILL_GRACE_MS = 500;
-// The one place node:child_process is imported — packages/integrations never
-// imports it directly. Uses spawn (never a shell) so stdout/stderr can be bounded
-// independently at the exact approved limits, and so the child process can be
-// terminated on timeout or overflow without waiting for it to finish producing output.
-export class NodeCommandRunner {
-    run(input) {
-        return new Promise((resolve, reject) => {
-            let stdout = '';
-            let stderr = '';
-            let timedOut = false;
-            let outputExceeded = false;
-            let settled = false;
-            let killTimer;
-            // An npm-installed claude is a .cmd shim on Windows: it runs through cmd.exe with every
-            // argument escaped — still never a shell string built from raw input.
-            const spawnable = spawnableCommand(input.executable, input.argv);
-            const child = spawn(spawnable.command, spawnable.args, {
-                cwd: input.cwd,
-                shell: false,
-                windowsVerbatimArguments: spawnable.windowsVerbatimArguments,
-                windowsHide: true,
-                // No stdin: nothing here ever answers a prompt (a command that wants
-                // confirmation must fail fast instead of waiting on an open pipe).
-                stdio: ['ignore', 'pipe', 'pipe'],
-            });
-            // SIGTERM first (lets a well-behaved process clean up); SIGKILL after a
-            // short grace period as a backstop against one that ignores it.
-            const terminate = () => {
-                child.kill('SIGTERM');
-                killTimer = setTimeout(() => {
-                    child.kill('SIGKILL');
-                }, KILL_GRACE_MS);
-            };
-            const timer = setTimeout(() => {
-                timedOut = true;
-                terminate();
-            }, input.timeoutMs);
-            child.stdout.on('data', (chunk) => {
-                stdout += chunk.toString('utf8');
-                if (Buffer.byteLength(stdout, 'utf8') > input.stdoutLimitBytes) {
-                    outputExceeded = true;
-                    terminate();
-                }
-            });
-            child.stderr.on('data', (chunk) => {
-                stderr += chunk.toString('utf8');
-                if (Buffer.byteLength(stderr, 'utf8') > input.stderrLimitBytes) {
-                    outputExceeded = true;
-                    terminate();
-                }
-            });
-            // Spawn-level failure (e.g. ENOENT — executable not found) is distinct
-            // from a completed process with a non-zero exit code. Only this case
-            // rejects the promise.
-            child.on('error', (error) => {
-                if (settled)
-                    return;
-                settled = true;
-                clearTimeout(timer);
-                clearTimeout(killTimer);
-                reject(error);
-            });
-            child.on('close', (code) => {
-                if (settled)
-                    return;
-                settled = true;
-                clearTimeout(timer);
-                clearTimeout(killTimer);
-                resolve({ stdout, stderr, exitCode: code, timedOut, outputExceeded });
-            });
-        });
-    }
-}