@powerhousedao/ph-clint-cli 0.1.0-dev.52 → 0.1.0-dev.54

package/dist/codegen/index.js

@@ -1,412 +1,11 @@
 /**
- * Code generator entry point.
- *
- * Takes a `ClintProjectSpec` + target directory and reconciles the on-disk
- * project tree with it.
- *
- * Two modes:
- *
- * - **create** — the target dir is empty (or only contains ignorable
- *   artefacts). Every templated file is written fresh. Refuses to
- *   overwrite existing non-empty state unless `allowNonEmpty`.
- *
- * - **update** — a previous run's spec exists at
- *   `.ph/ph-clint-cli/project-spec.json`. Re-runs the builders, then for
- *   each emitted file:
- *     - files containing `@clint:begin/@clint:end` markers (today: just
- *       `src/cli.ts`) have their marker regions spliced in-place, leaving
- *       user code outside markers untouched;
- *     - files without markers are overwritten iff their on-disk hash still
- *       matches the hash stored from the previous write (user-edited files
- *       are skipped and surfaced via `onWarn`);
- *     - files the new spec no longer emits are removed if their hash still
- *       matches.
- *
- * A spec flip of `features.powerhouse.enabled` from `false` to `true`
- * triggers the flat → split migration before the update flow runs.
- *
- * Mode is auto-detected by the presence of the persisted spec.
- */
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { getAppFolderName, getCliFolderName, } from '../spec/types.js';
-import { getSpecPath, readProjectSpec, writeProjectSpec, } from '../spec/file.js';
-import { hashContent, hashFile, readHashes, writeHashes, } from './hashes.js';
-import { hasMarkers, spliceMarkerRegions } from './markers.js';
-import { writeFileEnsuringDir, isDirEmptyEnough } from './write.js';
-import { migrateFlatToSplit } from './migrate/flat-to-split.js';
-import { CLI_FILE_BUILDERS, getProfileFileBuilders, buildReadme, buildRootPackageJson, buildPublishConfigJs, } from './builders/index.js';
-import { collectPostGenActions, } from './actions.js';
-import { readGeneratedState, writeGeneratedState, generatedStateFromSpec, } from './generated.js';
-import { patchAppPackageName } from './scaffold.js';
-/**
- * Generate / reconcile a project at `targetDir` from the given spec.
+ * Re-exports from @powerhousedao/ph-clint-dev/codegen with CLI_VERSION default.
  */
+import { generateProject as _generateProject, } from '@powerhousedao/ph-clint-dev/codegen';
+import { CLI_VERSION } from '../config.js';
 export async function generateProject(options) {
-    const { targetDir, spec } = options;
-    const warn = options.onWarn ?? (() => { });
-    const existingSpec = await readProjectSpec(targetDir);
-    const resolvedMode = resolveMode(options.mode ?? 'auto', existingSpec !== null);
-    // Flat → split migration, if needed. Runs BEFORE we compute planned files
-    // so the hash record and on-disk state are already in split-layout shape
-    // by the time the normal reconciliation runs.
-    //
-    // Use GeneratedState (what was *actually generated* last time) rather than
-    // the on-disk spec to detect the layout flip — when the user edits the spec
-    // file before running regen, both existingSpec and spec already say "Reactor"
-    // and the old comparison would never trigger.
-    let migrated = false;
-    if (resolvedMode === 'update' && spec.features.powerhouse !== 'Disabled') {
-        const prev = await readGeneratedState(targetDir);
-        const wasFlatLayout = prev ? prev.cliFolderName === '' : existingSpec?.features.powerhouse === 'Disabled';
-        if (wasFlatLayout) {
-            await migrateFlatToSplit({
-                targetDir,
-                spec,
-                force: options.force,
-                onWarn: warn,
-            });
-            migrated = true;
-        }
-    }
-    // Dispatch to the mode-specific flow.
-    if (resolvedMode === 'create') {
-        return runCreate(options, warn);
-    }
-    return runUpdate(options, warn, migrated);
-}
-function resolveMode(requested, specExists) {
-    if (requested === 'create')
-        return 'create';
-    if (requested === 'update')
-        return 'update';
-    return specExists ? 'update' : 'create';
-}
-/** Build the list of files the new spec would emit, with their content. */
-function planFiles(spec, targetDir) {
-    const split = spec.features.powerhouse !== 'Disabled';
-    const cliDir = split ? path.join(targetDir, getCliFolderName(spec)) : targetDir;
-    const appDir = split ? path.join(targetDir, getAppFolderName(spec)) : null;
-    const planned = [];
-    const allBuilders = [...CLI_FILE_BUILDERS, ...getProfileFileBuilders(spec)];
-    for (const builder of allBuilders) {
-        const content = builder.build(spec);
-        if (content === null)
-            continue;
-        const abs = path.join(cliDir, builder.relativePath);
-        planned.push({
-            relativePath: path.relative(targetDir, abs),
-            absolutePath: abs,
-            content,
-            initOnly: builder.initOnly,
-        });
-    }
-    // Project-root README — always at the top level.
-    const readmeAbs = path.join(targetDir, 'README.md');
-    planned.push({
-        relativePath: 'README.md',
-        absolutePath: readmeAbs,
-        content: buildReadme(spec),
+    return _generateProject({
+        ...options,
+        context: options.context ?? { toolVersion: CLI_VERSION },
     });
-    // Publish config — always at the project root (both layouts).
-    const publishConfig = path.join(targetDir, 'publish.config.js');
-    planned.push({
-        relativePath: 'publish.config.js',
-        absolutePath: publishConfig,
-        content: buildPublishConfigJs(spec),
-    });
-    // Split-layout only: root package.json + app placeholder files.
-    if (split && appDir) {
-        const rootPkg = path.join(targetDir, 'package.json');
-        planned.push({
-            relativePath: 'package.json',
-            absolutePath: rootPkg,
-            content: buildRootPackageJson(spec),
-        });
-        const appGitkeep = path.join(appDir, '.gitkeep');
-        planned.push({
-            relativePath: path.relative(targetDir, appGitkeep),
-            absolutePath: appGitkeep,
-            content: '',
-        });
-        const appReadme = path.join(appDir, 'README.md');
-        planned.push({
-            relativePath: path.relative(targetDir, appReadme),
-            absolutePath: appReadme,
-            content: buildAppReadmeContent(spec),
-        });
-    }
-    return { planned, cliDir, appDir };
-}
-function buildAppReadmeContent(spec) {
-    return [
-        `# ${spec.name}-app`,
-        '',
-        'Powerhouse reactor-package for this project. Scaffold it with:',
-        '',
-        '```sh',
-        `cd ${spec.name}-app`,
-        'ph init',
-        '```',
-        '',
-        'Then run `pnpm install` at the project root.',
-        '',
-    ].join('\n');
-}
-// ---------------------------------------------------------------------------
-// Folder rename handling
-// ---------------------------------------------------------------------------
-async function fileExists(filePath) {
-    try {
-        await fs.access(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Detect and execute folder renames when the project name changes.
- *
- * Reads the previous `GeneratedState` to find the old folder names, compares
- * with the new spec's folder names. If they differ:
- *   1. Renames the directories on disk.
- *   2. Rewrites hash-record keys from old → new prefixes.
- *
- * Must run BEFORE `planFiles()` so the reconciliation loop sees the files
- * in their new locations.
- */
-async function handleFolderRename(targetDir, spec, prev, warn) {
-    const split = spec.features.powerhouse !== 'Disabled';
-    if (!split || !prev || !prev.cliFolderName) {
-        return { renamed: false, appInitialized: prev?.appInitialized ?? false };
-    }
-    const newCliFolder = getCliFolderName(spec);
-    const newAppFolder = getAppFolderName(spec);
-    const oldCliFolder = prev.cliFolderName;
-    const oldAppFolder = prev.appFolderName;
-    if (oldCliFolder === newCliFolder && oldAppFolder === newAppFolder) {
-        return { renamed: false, appInitialized: prev.appInitialized };
-    }
-    // Rename CLI folder
-    if (oldCliFolder !== newCliFolder) {
-        const oldPath = path.join(targetDir, oldCliFolder);
-        const newPath = path.join(targetDir, newCliFolder);
-        if (await fileExists(oldPath)) {
-            if (await fileExists(newPath)) {
-                warn(`cannot rename ${oldCliFolder} → ${newCliFolder}: target already exists`);
-                return { renamed: false, appInitialized: prev.appInitialized };
-            }
-            await fs.rename(oldPath, newPath);
-        }
-    }
-    // Rename app folder
-    if (oldAppFolder !== newAppFolder) {
-        const oldPath = path.join(targetDir, oldAppFolder);
-        const newPath = path.join(targetDir, newAppFolder);
-        if (await fileExists(oldPath)) {
-            if (await fileExists(newPath)) {
-                warn(`cannot rename ${oldAppFolder} → ${newAppFolder}: target already exists`);
-                return { renamed: false, appInitialized: prev.appInitialized };
-            }
-            await fs.rename(oldPath, newPath);
-        }
-    }
-    // Rewrite hash keys from old folder prefixes to new ones
-    const hashes = await readHashes(targetDir);
-    const remapped = {};
-    for (const [key, value] of Object.entries(hashes)) {
-        let newKey = key;
-        if (oldCliFolder !== newCliFolder && key.startsWith(oldCliFolder + '/')) {
-            newKey = newCliFolder + key.slice(oldCliFolder.length);
-        }
-        else if (oldAppFolder !== newAppFolder &&
-            key.startsWith(oldAppFolder + '/')) {
-            newKey = newAppFolder + key.slice(oldAppFolder.length);
-        }
-        remapped[newKey] = value;
-    }
-    await writeHashes(targetDir, remapped);
-    return { renamed: true, appInitialized: prev.appInitialized };
-}
-/** Create mode — empty target dir, write everything fresh. */
-async function runCreate(options, _warn) {
-    const { targetDir, spec } = options;
-    if (!options.allowNonEmpty) {
-        const empty = await isDirEmptyEnough(targetDir);
-        if (!empty) {
-            throw new Error(`target directory ${targetDir} is not empty (pass allowNonEmpty or --force to override)`);
-        }
-    }
-    const { planned, cliDir, appDir } = planFiles(spec, targetDir);
-    const hashes = {};
-    const files = [];
-    for (const p of planned) {
-        await writeFileEnsuringDir(p.absolutePath, p.content);
-        hashes[p.relativePath] = hashContent(p.content);
-        files.push({ absolutePath: p.absolutePath, relativePath: p.relativePath });
-    }
-    await writeProjectSpec(targetDir, spec);
-    files.push({
-        absolutePath: getSpecPath(targetDir),
-        relativePath: path.relative(targetDir, getSpecPath(targetDir)),
-    });
-    await writeHashes(targetDir, hashes);
-    // App is not yet initialized on create — ph-init runs as a post-gen action.
-    await writeGeneratedState(targetDir, generatedStateFromSpec(spec, false));
-    const result = {
-        mode: 'create',
-        files,
-        skipped: [],
-        deleted: [],
-        migrated: false,
-        cliDir,
-        appDir,
-        pendingActions: [],
-    };
-    result.pendingActions = await collectPostGenActions(result, spec);
-    return result;
-}
-/** Update mode — reconcile against an existing project. */
-async function runUpdate(options, warn, migrated) {
-    const { targetDir, spec } = options;
-    const force = !!options.force;
-    // --- Folder rename detection ---
-    const prev = await readGeneratedState(targetDir);
-    const { renamed, appInitialized: appWasInitialized } = await handleFolderRename(targetDir, spec, prev, warn);
-    const { planned, cliDir, appDir } = planFiles(spec, targetDir);
-    const plannedByKey = new Map(planned.map((p) => [p.relativePath, p]));
-    const previous = await readHashes(targetDir);
-    const next = {};
-    const files = [];
-    const skipped = [];
-    const deleted = [];
-    // Step 1: write / patch / skip each planned file.
-    for (const p of planned) {
-        if (p.initOnly) {
-            // User-owned files (e.g. `src/framework.ts` with its `configSchema`)
-            // are emitted only on create. In update mode we never overwrite them —
-            // but we DO create them if they don't yet exist on disk (e.g. first
-            // spec-change trigger run where no explicit `init` was run before).
-            const onDisk = await hashFile(p.absolutePath);
-            if (onDisk === null && p.content) {
-                await writeFileEnsuringDir(p.absolutePath, p.content);
-                next[p.relativePath] = hashContent(p.content);
-                files.push({ absolutePath: p.absolutePath, relativePath: p.relativePath });
-            }
-            else {
-                const stored = previous[p.relativePath];
-                if (stored !== undefined)
-                    next[p.relativePath] = stored;
-            }
-            continue;
-        }
-        const existing = await hashFile(p.absolutePath);
-        if (existing === null) {
-            // Not yet on disk — fresh write.
-            await writeFileEnsuringDir(p.absolutePath, p.content);
-            next[p.relativePath] = hashContent(p.content);
-            files.push({
-                absolutePath: p.absolutePath,
-                relativePath: p.relativePath,
-            });
-            continue;
-        }
-        // File exists. Decide how to update it.
-        if (hasMarkers(p.content)) {
-            const existingContent = await fs.readFile(p.absolutePath, 'utf8');
-            const patched = hasMarkers(existingContent)
-                ? spliceMarkerRegions(existingContent, p.content)
-                : p.content;
-            if (patched === existingContent) {
-                // No-op: regions already match.
-                next[p.relativePath] = hashContent(patched);
-                continue;
-            }
-            await writeFileEnsuringDir(p.absolutePath, patched);
-            next[p.relativePath] = hashContent(patched);
-            files.push({
-                absolutePath: p.absolutePath,
-                relativePath: p.relativePath,
-            });
-            continue;
-        }
-        // No markers — hash-protected overwrite.
-        const stored = previous[p.relativePath];
-        const pristine = stored !== undefined && stored === existing;
-        if (!pristine && !force) {
-            // User edited a managed file. Leave it alone.
-            warn(`skipped ${p.relativePath} — modified since last generation. Use --force to overwrite.`);
-            skipped.push({
-                absolutePath: p.absolutePath,
-                relativePath: p.relativePath,
-            });
-            // Preserve the previous hash so the file stays on our ledger.
-            if (stored !== undefined)
-                next[p.relativePath] = stored;
-            continue;
-        }
-        if (existing === hashContent(p.content)) {
-            // Already up to date.
-            next[p.relativePath] = existing;
-            continue;
-        }
-        await writeFileEnsuringDir(p.absolutePath, p.content);
-        next[p.relativePath] = hashContent(p.content);
-        files.push({
-            absolutePath: p.absolutePath,
-            relativePath: p.relativePath,
-        });
-    }
-    // Step 2: delete files that the new spec no longer emits, IF we still
-    // recognise their content (hash match). Otherwise warn and keep.
-    for (const [relPath, storedHash] of Object.entries(previous)) {
-        if (plannedByKey.has(relPath))
-            continue;
-        const abs = path.join(targetDir, relPath);
-        const onDisk = await hashFile(abs);
-        if (onDisk === null)
-            continue; // already gone
-        if (onDisk !== storedHash && !force) {
-            warn(`kept ${relPath} — modified since last generation; new spec no longer emits it.`);
-            next[relPath] = storedHash;
-            continue;
-        }
-        await fs.rm(abs, { force: true });
-        deleted.push({ absolutePath: abs, relativePath: relPath });
-    }
-    await writeProjectSpec(targetDir, spec);
-    await writeHashes(targetDir, next);
-    // Re-patch app package.json if name or scope changed and app is initialized.
-    // Add to `files` so collectPostGenActions sees the change and triggers
-    // app-install → app-build → cli-install → cli-build.
-    const appIsInitialized = appDir
-        ? await fileExists(path.join(appDir, 'package.json'))
-        : false;
-    const nameOrScopeChanged = prev
-        ? prev.name !== spec.name || prev.scope !== spec.scope
-        : false;
-    if (appDir && appIsInitialized && nameOrScopeChanged) {
-        const patched = await patchAppPackageName(appDir, spec, warn);
-        if (patched) {
-            const appFolder = path.basename(appDir);
-            files.push({
-                absolutePath: path.join(appDir, 'package.json'),
-                relativePath: path.join(appFolder, 'package.json'),
-            });
-        }
-    }
-    await writeGeneratedState(targetDir, generatedStateFromSpec(spec, appIsInitialized));
-    const result = {
-        mode: 'update',
-        files,
-        skipped,
-        deleted,
-        migrated,
-        cliDir,
-        appDir,
-        pendingActions: [],
-    };
-    result.pendingActions = await collectPostGenActions(result, spec);
-    return result;
 }

package/dist/codegen/markers.d.ts

@@ -1,36 +1 @@
-/**
- * Marker-region parsing for `@clint:begin {name}` / `@clint:end {name}`
- * comment blocks. Used in delta mode to splice freshly-generated regions
- * into an existing, user-edited file while preserving everything outside
- * the markers.
- *
- * The only syntactic requirement is that the markers are on their own lines,
- * as ordinary line comments (`//`). Indentation is preserved for output.
- */
-export interface MarkerRegion {
-    /** Region identifier (the text after `@clint:begin`). */
-    name: string;
-    /** Lines *between* the begin and end markers (exclusive). */
-    body: string[];
-    /** Indentation of the begin line — used when rewriting. */
-    indent: string;
-    /** Line index of the begin marker in the source. */
-    beginLine: number;
-    /** Line index of the end marker in the source. */
-    endLine: number;
-}
-/**
- * Parse every `@clint:begin {name}` … `@clint:end {name}` block in `source`.
- * Throws if markers are mismatched or unclosed.
- */
-export declare function parseMarkerRegions(source: string): MarkerRegion[];
-/**
- * Replace every region in `target` that also exists in `source` with the
- * `source` region's body. Leaves regions present in `target` but not `source`
- * untouched. Ignores regions in `source` missing from `target`.
- *
- * Returns the rewritten file content.
- */
-export declare function spliceMarkerRegions(target: string, source: string): string;
-/** Convenience — true if `content` contains at least one `@clint:begin`. */
-export declare function hasMarkers(content: string): boolean;
+export { type MarkerRegion, parseMarkerRegions, spliceMarkerRegions, hasMarkers, } from '@powerhousedao/ph-clint-dev/codegen/markers';

package/dist/codegen/markers.js

@@ -1,86 +1 @@
-/**
- * Marker-region parsing for `@clint:begin {name}` / `@clint:end {name}`
- * comment blocks. Used in delta mode to splice freshly-generated regions
- * into an existing, user-edited file while preserving everything outside
- * the markers.
- *
- * The only syntactic requirement is that the markers are on their own lines,
- * as ordinary line comments (`//`). Indentation is preserved for output.
- */
-const BEGIN_RE = /^([ \t]*)\/\/\s*@clint:begin\s+(\S+)\s*$/;
-const END_RE = /^([ \t]*)\/\/\s*@clint:end\s+(\S+)\s*$/;
-/**
- * Parse every `@clint:begin {name}` … `@clint:end {name}` block in `source`.
- * Throws if markers are mismatched or unclosed.
- */
-export function parseMarkerRegions(source) {
-    const lines = source.split('\n');
-    const regions = [];
-    let open = null;
-    let bodyStart = 0;
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        const begin = BEGIN_RE.exec(line);
-        if (begin) {
-            if (open) {
-                throw new Error(`nested @clint:begin ${begin[2]} at line ${i + 1} while ${open.name} is still open`);
-            }
-            open = { name: begin[2], indent: begin[1], beginLine: i };
-            bodyStart = i + 1;
-            continue;
-        }
-        const end = END_RE.exec(line);
-        if (end) {
-            if (!open) {
-                throw new Error(`@clint:end ${end[2]} at line ${i + 1} without matching begin`);
-            }
-            if (open.name !== end[2]) {
-                throw new Error(`@clint:end ${end[2]} at line ${i + 1} does not match open @clint:begin ${open.name}`);
-            }
-            regions.push({
-                name: open.name,
-                body: lines.slice(bodyStart, i),
-                indent: open.indent,
-                beginLine: open.beginLine,
-                endLine: i,
-            });
-            open = null;
-        }
-    }
-    if (open) {
-        throw new Error(`unterminated @clint:begin ${open.name}`);
-    }
-    return regions;
-}
-/**
- * Replace every region in `target` that also exists in `source` with the
- * `source` region's body. Leaves regions present in `target` but not `source`
- * untouched. Ignores regions in `source` missing from `target`.
- *
- * Returns the rewritten file content.
- */
-export function spliceMarkerRegions(target, source) {
-    const sourceRegions = parseMarkerRegions(source);
-    const sourceByName = new Map();
-    for (const r of sourceRegions)
-        sourceByName.set(r.name, r);
-    const targetRegions = parseMarkerRegions(target);
-    if (targetRegions.length === 0)
-        return target;
-    const lines = target.split('\n');
-    // Apply replacements from last to first so line indices stay valid.
-    const sorted = [...targetRegions].sort((a, b) => b.beginLine - a.beginLine);
-    for (const region of sorted) {
-        const fresh = sourceByName.get(region.name);
-        if (!fresh)
-            continue;
-        // Replace the body lines (exclusive of the begin/end marker lines).
-        const bodyLen = region.endLine - region.beginLine - 1;
-        lines.splice(region.beginLine + 1, bodyLen, ...fresh.body);
-    }
-    return lines.join('\n');
-}
-/** Convenience — true if `content` contains at least one `@clint:begin`. */
-export function hasMarkers(content) {
-    return /^[ \t]*\/\/\s*@clint:begin\s+\S+\s*$/m.test(content);
-}
+export { parseMarkerRegions, spliceMarkerRegions, hasMarkers, } from '@powerhousedao/ph-clint-dev/codegen/markers';

package/dist/codegen/scaffold.d.ts

@@ -1,72 +1 @@
-import type { ClintProjectSpec } from '../spec/types.js';
-import type { ProcessRunOptions } from '@powerhousedao/ph-clint';
-/**
- * Signature for the subprocess runner — matches CommandContext.runProcess.
- */
-type RunProcess = (command: string, opts?: Omit<ProcessRunOptions, 'onOutput'>) => Promise<{
-    success: boolean;
-    output: string;
-}>;
-export type { RunProcess };
-export interface PhInitOptions {
-    /** Absolute path to the project root. */
-    targetDir: string;
-    /** Absolute path to `{targetDir}/{name}-app` (exists with our placeholder). */
-    appDir: string;
-    spec: ClintProjectSpec;
-    /** Logger; defaults to noop. */
-    log?: (msg: string) => void;
-    /** Override `ph` binary name (for tests). */
-    binName?: string;
-    /** Subprocess runner — matches CommandContext.runProcess. */
-    runProcess: RunProcess;
-    /** Explicit Powerhouse version to pin `ph init` to (tag or semver). */
-    phVersion?: string;
-}
-export interface PhInitResult {
-    ran: boolean;
-    exitCode?: number;
-    reason?: string;
-}
-/**
- * Detect the installed `ph` CLI version by parsing `ph --version` output.
- * Returns the version string (e.g. '6.0.0-dev.194') or undefined if
- * detection fails.
- */
-export declare function getPhVersion(binName: string): string | undefined;
-export declare function runPhInit(options: PhInitOptions): Promise<PhInitResult>;
-/**
- * Patch the app `package.json` name to the scoped form (`@scope/name-app`).
- * Called after `ph init` and after name/scope renames.
- *
- * Returns `true` if the file was actually changed.
- */
-export declare function patchAppPackageName(appDir: string, spec: {
-    name: string;
-    scope?: string;
-}, log?: (msg: string) => void): Promise<boolean>;
-/**
- * Run `ph install <packages> --local --pnpm` in the app directory to register
- * external packages in `powerhouse.config.json`.
- */
-export declare function runPhInstallPackages(options: {
-    appDir: string;
-    packages: string[];
-    log?: (msg: string) => void;
-    runProcess: RunProcess;
-}): Promise<boolean>;
-export interface PnpmInstallOptions {
-    /** Directories to run `pnpm install` in, in order. */
-    dirs: string[];
-    log?: (msg: string) => void;
-    /** Override `pnpm` binary name (for tests). */
-    binName?: string;
-    /** Subprocess runner — matches CommandContext.runProcess. */
-    runProcess: RunProcess;
-}
-export interface PnpmInstallResult {
-    ran: string[];
-    skipped: string[];
-    reason?: string;
-}
-export declare function runPnpmInstall(options: PnpmInstallOptions): Promise<PnpmInstallResult>;
+export { type RunProcess, type PhInitOptions, type PhInitResult, getPhVersion, runPhInit, patchAppPackageName, type PnpmInstallOptions, type PnpmInstallResult, runPnpmInstall, runPhInstallPackages, } from '@powerhousedao/ph-clint-dev/codegen/scaffold';