@powerhousedao/ph-clint-cli 0.1.0-dev.75 → 0.1.0-dev.77

package/dist/codegen/actions.d.ts

@@ -1 +1,46 @@
-export { type PostGenAction, type PostGenActionKind, type PostGenActionContext, type PostGenActionResult, collectPostGenActions, runPostGenActions, } from '@powerhousedao/ph-clint-dev/codegen/actions';
+import type { GenerateProjectResult } from './index.js';
+import type { ClintProjectSpec, ExternalSkill } from '../spec/types.js';
+import type { ProcessRunOptions } from '@powerhousedao/ph-clint';
+export type PostGenAction = {
+    kind: 'ph-init';
+    targetDir: string;
+    appDir: string;
+    spec: ClintProjectSpec;
+} | {
+    kind: 'app-install';
+    dir: string;
+} | {
+    kind: 'app-ph-install';
+    appDir: string;
+    packages: string[];
+} | {
+    kind: 'app-build';
+    dir: string;
+} | {
+    kind: 'cli-install';
+    dir: string;
+} | {
+    kind: 'cli-build';
+    dir: string;
+} | {
+    kind: 'skills-sync';
+    targetDir: string;
+    desired: ExternalSkill[];
+};
+export type PostGenActionKind = PostGenAction['kind'];
+export interface PostGenActionContext {
+    log: (msg: string) => void;
+    runProcess: (command: string, opts?: Omit<ProcessRunOptions, 'onOutput'>) => Promise<{
+        success: boolean;
+        output: string;
+    }>;
+    skip?: Set<PostGenActionKind>;
+}
+export interface PostGenActionResult {
+    action: PostGenAction;
+    status: 'success' | 'failed' | 'skipped';
+    reason?: string;
+    durationMs: number;
+}
+export declare function collectPostGenActions(result: GenerateProjectResult, spec: ClintProjectSpec): Promise<PostGenAction[]>;
+export declare function runPostGenActions(actions: PostGenAction[], ctx: PostGenActionContext): Promise<PostGenActionResult[]>;

package/dist/codegen/actions.js

@@ -1 +1,424 @@
-export { collectPostGenActions, runPostGenActions, } from '@powerhousedao/ph-clint-dev/codegen/actions';
+/**
+ * Post-generation actions — a typed pipeline that runs after codegen.
+ *
+ * `collectPostGenActions()` inspects a `GenerateProjectResult` to determine
+ * which side-effects (install, build, ph-init, skills-sync) are needed.
+ *
+ * `runPostGenActions()` executes them sequentially with proper ordering,
+ * failure cascading, and log output.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getAppPackageName } from '../spec/types.js';
+// ---------------------------------------------------------------------------
+// Fixed execution order — index defines precedence
+// ---------------------------------------------------------------------------
+const ACTION_ORDER = [
+    'ph-init',
+    'app-install',
+    'app-ph-install',
+    'app-build',
+    'cli-install',
+    'cli-build',
+    'skills-sync',
+];
+function actionIndex(kind) {
+    return ACTION_ORDER.indexOf(kind);
+}
+// ---------------------------------------------------------------------------
+// Dependency map — which actions depend on which (for failure cascading)
+// ---------------------------------------------------------------------------
+/** Returns true if `downstream` depends on `upstream` succeeding. */
+function dependsOn(downstream, upstream) {
+    // ph-init → app-install → app-ph-install → app-build → cli-install → cli-build
+    // skills-sync is independent of the build chain
+    const chain = [
+        'ph-init',
+        'app-install',
+        'app-ph-install',
+        'app-build',
+        'cli-install',
+        'cli-build',
+    ];
+    if (downstream === 'skills-sync')
+        return false;
+    const di = chain.indexOf(downstream);
+    const ui = chain.indexOf(upstream);
+    if (di < 0 || ui < 0)
+        return false;
+    return di > ui;
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** External packages that have document types (not the app package). */
+function getExternalPackages(spec) {
+    const appPkg = getAppPackageName(spec);
+    return spec.packages.filter((p) => p.packageName !== appPkg && p.documentTypes.length > 0);
+}
+/**
+ * Returns package names from `extPkgs` that are not yet registered in
+ * the app's `powerhouse.config.json`.
+ */
+async function getMissingPhPackages(appDir, extPkgs) {
+    try {
+        const raw = await fs.readFile(path.join(appDir, 'powerhouse.config.json'), 'utf8');
+        const config = JSON.parse(raw);
+        const registered = new Set((config.packages ?? []).map((p) => p.packageName));
+        return extPkgs
+            .map((p) => p.packageName)
+            .filter((name) => !registered.has(name));
+    }
+    catch {
+        // No config file yet (pre-init) — all packages are missing
+        return extPkgs.map((p) => p.packageName);
+    }
+}
+// ---------------------------------------------------------------------------
+// collectPostGenActions
+// ---------------------------------------------------------------------------
+export async function collectPostGenActions(result, spec) {
+    const split = result.appDir !== null;
+    const relPaths = new Set(result.files.map((f) => f.relativePath));
+    // Determine the earliest triggered action in the chain
+    let earliest = null;
+    if (split) {
+        const appFolder = result.appDir ? path.basename(result.appDir) : '';
+        const cliFolder = path.basename(result.cliDir);
+        // ph-init needed: app dir placeholder written but app not yet initialized.
+        // Check the actual filesystem — if package.json already exists on disk,
+        // ph init has already run and must not run again.
+        const appPkgJsonChanged = relPaths.has(path.join(appFolder, 'package.json'));
+        const appGitkeepWritten = relPaths.has(path.join(appFolder, '.gitkeep'));
+        // ph-init needed: app dir placeholder written but app not yet initialized.
+        // Check the actual filesystem — if package.json already exists on disk,
+        // ph init has already run and must not run again.
+        if (appGitkeepWritten && !appPkgJsonChanged) {
+            const appAlreadyInitialized = result.appDir
+                ? await fileExists(path.join(result.appDir, 'package.json'))
+                : false;
+            if (!appAlreadyInitialized) {
+                earliest = 'ph-init';
+            }
+        }
+        // Migration always triggers full rebuild
+        if (result.migrated) {
+            earliest = earliest ?? 'app-install';
+        }
+        // App package.json changed
+        if (!earliest && appPkgJsonChanged) {
+            earliest = 'app-install';
+        }
+        // App source regenerated (framework.gen.ts, index.ts, etc.)
+        if (!earliest) {
+            for (const rel of relPaths) {
+                if (rel.startsWith(appFolder + '/') &&
+                    rel.endsWith('.ts')) {
+                    earliest = 'app-build';
+                    break;
+                }
+            }
+        }
+        // CLI package.json changed
+        if (!earliest) {
+            if (relPaths.has(path.join(cliFolder, 'package.json'))) {
+                earliest = 'cli-install';
+            }
+        }
+        // CLI source or prompts regenerated (.ts files, agent profile .md files)
+        if (!earliest) {
+            for (const rel of relPaths) {
+                if (rel.startsWith(cliFolder + '/') &&
+                    (rel.endsWith('.ts') || rel.endsWith('.md'))) {
+                    earliest = 'cli-build';
+                    break;
+                }
+            }
+        }
+    }
+    else {
+        // Flat layout
+        if (relPaths.has('package.json')) {
+            earliest = 'cli-install';
+        }
+        else {
+            for (const rel of relPaths) {
+                if (rel.endsWith('.ts') || rel.endsWith('.md')) {
+                    earliest = 'cli-build';
+                    break;
+                }
+            }
+        }
+    }
+    // Check if external packages need registering in the app
+    const extPkgs = split && result.appDir ? getExternalPackages(spec) : [];
+    if (split && result.appDir && extPkgs.length > 0) {
+        const missing = await getMissingPhPackages(result.appDir, extPkgs);
+        if (missing.length > 0) {
+            if (!earliest || actionIndex(earliest) > actionIndex('app-ph-install')) {
+                earliest = 'app-ph-install';
+            }
+        }
+    }
+    // Build the action list from earliest onward
+    const actions = [];
+    if (earliest && split && result.appDir) {
+        const ei = actionIndex(earliest);
+        if (ei <= actionIndex('ph-init')) {
+            actions.push({
+                kind: 'ph-init',
+                targetDir: path.dirname(result.appDir),
+                appDir: result.appDir,
+                spec,
+            });
+        }
+        if (ei <= actionIndex('app-install')) {
+            actions.push({ kind: 'app-install', dir: result.appDir });
+        }
+        if (ei <= actionIndex('app-ph-install') && extPkgs.length > 0) {
+            const missing = await getMissingPhPackages(result.appDir, extPkgs);
+            if (missing.length > 0) {
+                actions.push({ kind: 'app-ph-install', appDir: result.appDir, packages: missing });
+            }
+        }
+        if (ei <= actionIndex('app-build')) {
+            // Add install if not already in the list and node_modules is missing
+            if (!actions.some(a => a.kind === 'app-install') &&
+                !(await fileExists(path.join(result.appDir, 'node_modules')))) {
+                actions.push({ kind: 'app-install', dir: result.appDir });
+            }
+            actions.push({ kind: 'app-build', dir: result.appDir });
+        }
+        if (ei <= actionIndex('cli-install')) {
+            actions.push({ kind: 'cli-install', dir: result.cliDir });
+        }
+        if (ei <= actionIndex('cli-build')) {
+            // Add install if not already in the list and node_modules is missing
+            if (!actions.some(a => a.kind === 'cli-install') &&
+                !(await fileExists(path.join(result.cliDir, 'node_modules')))) {
+                actions.push({ kind: 'cli-install', dir: result.cliDir });
+            }
+            actions.push({ kind: 'cli-build', dir: result.cliDir });
+        }
+    }
+    else if (earliest && !split) {
+        const ei = actionIndex(earliest);
+        if (ei <= actionIndex('cli-install')) {
+            actions.push({ kind: 'cli-install', dir: result.cliDir });
+        }
+        if (ei <= actionIndex('cli-build')) {
+            // Add install if not already in the list and node_modules is missing
+            if (!actions.some(a => a.kind === 'cli-install') &&
+                !(await fileExists(path.join(result.cliDir, 'node_modules')))) {
+                actions.push({ kind: 'cli-install', dir: result.cliDir });
+            }
+            actions.push({ kind: 'cli-build', dir: result.cliDir });
+        }
+    }
+    // skills-sync is independent — append if needed
+    if (spec.externalSkills.length > 0) {
+        const targetDir = split ? result.cliDir : result.cliDir;
+        actions.push({
+            kind: 'skills-sync',
+            targetDir,
+            desired: spec.externalSkills,
+        });
+    }
+    return actions;
+}
+// ---------------------------------------------------------------------------
+// Human-readable label for an action
+// ---------------------------------------------------------------------------
+function actionLabel(action) {
+    switch (action.kind) {
+        case 'ph-init':
+            return `Initialize reactor package (${path.basename(action.appDir)})`;
+        case 'app-install':
+            return `Install dependencies (${path.basename(action.dir)})`;
+        case 'app-ph-install':
+            return `Register external packages (${action.packages.join(', ')})`;
+        case 'app-build':
+            return `Build (${path.basename(action.dir)})`;
+        case 'cli-install':
+            return `Install dependencies (${path.basename(action.dir)})`;
+        case 'cli-build':
+            return `Build (${path.basename(action.dir)})`;
+        case 'skills-sync':
+            return `Sync external skills (${action.desired.length} skill${action.desired.length === 1 ? '' : 's'})`;
+    }
+}
+// ---------------------------------------------------------------------------
+// runPostGenActions — effectful runner
+// ---------------------------------------------------------------------------
+export async function runPostGenActions(actions, ctx) {
+    if (actions.length === 0)
+        return [];
+    const skip = ctx.skip ?? new Set();
+    // Filter out explicitly skipped actions. Also skip builds if their
+    // corresponding install is skipped (building without install is pointless).
+    const effective = actions.filter((a) => {
+        if (skip.has(a.kind))
+            return false;
+        // If app-install is skipped, also skip app-ph-install and app-build
+        if (a.kind === 'app-ph-install' && skip.has('app-install'))
+            return false;
+        if (a.kind === 'app-build' && skip.has('app-install'))
+            return false;
+        // If cli-install is skipped, also skip cli-build
+        if (a.kind === 'cli-build' && skip.has('cli-install'))
+            return false;
+        return true;
+    });
+    if (effective.length === 0)
+        return [];
+    // Print numbered summary
+    ctx.log(`\nPost-generation steps (${effective.length}):`);
+    effective.forEach((a, i) => {
+        ctx.log(`  ${i + 1}. ${actionLabel(a)}`);
+    });
+    ctx.log('');
+    const results = [];
+    const failed = new Set();
+    for (let i = 0; i < effective.length; i++) {
+        const action = effective[i];
+        const label = actionLabel(action);
+        const prefix = `[${i + 1}/${effective.length}]`;
+        // Check if a dependency failed
+        const failedDep = [...failed].find((f) => dependsOn(action.kind, f));
+        if (failedDep) {
+            ctx.log(`${prefix} ${label}... skipped (dependency failed)`);
+            results.push({
+                action,
+                status: 'skipped',
+                reason: 'dependency failed',
+                durationMs: 0,
+            });
+            continue;
+        }
+        ctx.log(`${prefix} ${label}...`);
+        const t0 = Date.now();
+        try {
+            const success = await executeAction(action, ctx);
+            const elapsed = Date.now() - t0;
+            if (success) {
+                ctx.log(`      done (${formatDuration(elapsed)})`);
+                results.push({ action, status: 'success', durationMs: elapsed });
+            }
+            else {
+                ctx.log(`      FAILED`);
+                results.push({ action, status: 'failed', durationMs: elapsed });
+                failed.add(action.kind);
+            }
+        }
+        catch (err) {
+            const elapsed = Date.now() - t0;
+            const msg = err instanceof Error ? err.message : String(err);
+            ctx.log(`      FAILED: ${msg}`);
+            results.push({
+                action,
+                status: 'failed',
+                reason: msg,
+                durationMs: elapsed,
+            });
+            failed.add(action.kind);
+        }
+    }
+    // Print summary
+    const succeeded = results.filter((r) => r.status === 'success').length;
+    const failedCount = results.filter((r) => r.status === 'failed').length;
+    const skippedCount = results.filter((r) => r.status === 'skipped').length;
+    ctx.log('');
+    if (failedCount === 0 && skippedCount === 0) {
+        ctx.log(`Post-generation: ${succeeded} step${succeeded === 1 ? '' : 's'} completed successfully.`);
+        ctx.log('Ready — run `pnpm dev` to start.');
+    }
+    else {
+        ctx.log(`Post-generation: ${succeeded} succeeded, ${failedCount} failed, ${skippedCount} skipped.`);
+        if (failedCount > 0) {
+            ctx.log('Fix the reported error(s) and re-run `ph-clint clint-project-regen`.');
+        }
+    }
+    return results;
+}
+// ---------------------------------------------------------------------------
+// Action dispatch
+// ---------------------------------------------------------------------------
+async function executeAction(action, ctx) {
+    switch (action.kind) {
+        case 'ph-init': {
+            const { runPhInit } = await import('./scaffold.js');
+            const result = await runPhInit({
+                targetDir: action.targetDir,
+                appDir: action.appDir,
+                spec: action.spec,
+                log: (msg) => ctx.log(`      ${msg}`),
+                runProcess: ctx.runProcess,
+            });
+            if (!result.ran) {
+                ctx.log(`      ${result.reason ?? 'ph init did not run'}`);
+                return false;
+            }
+            if (result.exitCode === 0) {
+                // Mark app as initialized in generated state
+                const { readGeneratedState, writeGeneratedState } = await import('./generated.js');
+                const gen = await readGeneratedState(action.targetDir);
+                if (gen) {
+                    gen.appInitialized = true;
+                    await writeGeneratedState(action.targetDir, gen);
+                }
+            }
+            return result.exitCode === 0;
+        }
+        case 'app-ph-install': {
+            const { runPhInstallPackages } = await import('./scaffold.js');
+            return runPhInstallPackages({
+                appDir: action.appDir,
+                packages: action.packages,
+                log: (msg) => ctx.log(`      ${msg}`),
+                runProcess: ctx.runProcess,
+            });
+        }
+        case 'app-install':
+        case 'cli-install': {
+            const result = await ctx.runProcess('pnpm install', {
+                cwd: action.dir,
+                timeout: 300_000,
+            });
+            return result.success;
+        }
+        case 'app-build':
+        case 'cli-build': {
+            return runBuild(action.dir, ctx);
+        }
+        case 'skills-sync': {
+            const { syncExternalSkills } = await import('../skills/sync.js');
+            await syncExternalSkills({
+                targetDir: action.targetDir,
+                desired: action.desired,
+                log: (msg) => ctx.log(`      ${msg}`),
+            });
+            return true;
+        }
+    }
+}
+async function runBuild(dir, ctx) {
+    const result = await ctx.runProcess('pnpm build', {
+        cwd: dir,
+        timeout: 120_000,
+    });
+    return result.success;
+}
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    return `${(ms / 1000).toFixed(1)}s`;
+}

package/dist/codegen/builders/cli-package-json.d.ts

@@ -1 +1,8 @@
-export { buildCliPackageJson } from '@powerhousedao/ph-clint-dev/codegen/builders';
+/**
+ * Builds the CLI-side `package.json` (the ph-clint CLI itself).
+ *
+ * When `features.powerhouse.enabled`, this file lives at
+ * `{root}/{name}-cli/package.json`. Otherwise at `{root}/package.json`.
+ */
+import { type ClintProjectSpec } from '../../spec/types.js';
+export declare function buildCliPackageJson(spec: ClintProjectSpec): string;

package/dist/codegen/builders/cli-package-json.js

@@ -1 +1,128 @@
-export { buildCliPackageJson } from '@powerhousedao/ph-clint-dev/codegen/builders';
+/**
+ * Builds the CLI-side `package.json` (the ph-clint CLI itself).
+ *
+ * When `features.powerhouse.enabled`, this file lives at
+ * `{root}/{name}-cli/package.json`. Otherwise at `{root}/package.json`.
+ */
+import { getAppDirName, getAppPackageName, getBinName, getPackageName, phAtLeast, } from '../../spec/types.js';
+import { CLI_VERSION } from '../../config.js';
+import { getPhVersion } from '../scaffold.js';
+/**
+ * Derive a semver range from the running ph-clint-cli version that respects
+ * the dev / staging / production channel boundary. This is the version range
+ * emitted into *scaffolded* projects' package.json for @powerhousedao/ph-clint
+ * and @powerhousedao/ph-clint-dev dependencies.
+ *
+ * CLI_VERSION is the version of ph-clint-cli itself (read from its own
+ * package.json at startup). Since all framework packages share a lockstep
+ * version, this is also the correct base for the dependency range.
+ *
+ * Examples:
+ *   "0.1.0"            → "^0.1.0"            (production — stable only)
+ *   "0.1.0-staging.2"  → "^0.1.0-staging.0"  (staging + stable)
+ *   "0.1.0-dev.4"      → "^0.1.0-dev.0"      (dev + staging + stable)
+ *
+ * This works because semver orders prereleases alphabetically:
+ * dev.N < staging.N < release. A caret range starting at dev.0 naturally
+ * upgrades through staging to production.
+ */
+function phClintRange(version) {
+    const match = /^(\d+\.\d+\.\d+)(?:-([a-z]+)\.\d+)?/.exec(version);
+    if (!match)
+        return `^${version}`;
+    const base = match[1];
+    const channel = match[2]; // "dev", "staging", or undefined
+    // For prerelease channels, pin exact version. Caret ranges like ^0.1.0-dev.0
+    // resolve to `latest` dist-tag (0.1.0-dev.0) instead of the highest match,
+    // causing "export not found" errors when the scaffolding CLI is newer.
+    return channel ? version : `^${base}`;
+}
+/** Version range for @powerhousedao/ph-clint{,-dev} deps in scaffolded projects. */
+const PH_CLINT_VERSION = phClintRange(CLI_VERSION);
+const POWERHOUSE_VERSION_FALLBACK = '6.0.0-dev.170';
+let _powerhouseVersion;
+function getPowerhouseVersion() {
+    if (_powerhouseVersion === undefined) {
+        _powerhouseVersion = getPhVersion('ph') ?? POWERHOUSE_VERSION_FALLBACK;
+    }
+    return _powerhouseVersion;
+}
+export function buildCliPackageJson(spec) {
+    const { mastra, powerhouse } = spec.features;
+    const pkgName = getPackageName(spec);
+    const bin = getBinName(spec);
+    const dependencies = {
+        '@powerhousedao/ph-clint': PH_CLINT_VERSION,
+        zod: '^4.3.6',
+    };
+    if (mastra.enabled) {
+        dependencies['@mastra/core'] = '^1.22.0';
+        dependencies['@mastra/libsql'] = '^1.7.4';
+        dependencies['@mastra/mcp'] = '^1.4.1';
+        dependencies['@mastra/memory'] = '^1.13.1';
+    }
+    if (phAtLeast(powerhouse, 'Reactor')) {
+        const appPkg = getAppPackageName(spec);
+        const appDir = getAppDirName(spec);
+        dependencies[appPkg] = `file:../${appDir}`;
+        dependencies['@powerhousedao/reactor'] = getPowerhouseVersion();
+        dependencies['@powerhousedao/reactor-api'] = getPowerhouseVersion();
+        dependencies['@powerhousedao/shared'] = getPowerhouseVersion();
+        dependencies['document-model'] = getPowerhouseVersion();
+        // External reactor packages (non-app) as versioned dependencies.
+        // Compare bare names (without scope) so that a spec entry with
+        // packageName "foo-app" still matches the scoped "@scope/foo-app".
+        const appBare = appPkg.replace(/^@[^/]+\//, '');
+        for (const pkg of spec.packages) {
+            const pkgBare = pkg.packageName.replace(/^@[^/]+\//, '');
+            if (pkgBare === appBare)
+                continue;
+            dependencies[pkg.packageName] = 'latest';
+        }
+    }
+    const scripts = {
+        'build:skills': 'tsx scripts/build-skills.ts',
+        'build:manifest': 'build-manifest',
+        build: 'pnpm build:skills && tsc && pnpm build:manifest',
+        dev: 'tsx src/main.ts',
+        start: 'node dist/main.js',
+        test: "NODE_OPTIONS='--experimental-vm-modules' jest --detectOpenHandles",
+        lint: 'eslint src',
+    };
+    if (mastra.enabled) {
+        scripts['mastra:dev'] = 'mastra dev';
+        scripts['mastra:build'] = 'mastra build';
+        scripts['mastra:start'] = 'mastra start';
+    }
+    // Single-layout: publish scripts live in the CLI package.json (which IS the
+    // root). Split-layout gets these from root-package-json.ts instead.
+    if (!phAtLeast(powerhouse, 'Reactor')) {
+        scripts['publish:dev'] = 'ph-publish dev -c ./publish.config.js';
+        scripts['publish:staging'] = 'ph-publish staging -c ./publish.config.js';
+        scripts['publish:production'] = 'ph-publish production -c ./publish.config.js';
+    }
+    const pkg = {
+        name: pkgName,
+        version: spec.version,
+        publishConfig: { access: 'public' },
+        type: 'module',
+    };
+    if (spec.description)
+        pkg.description = spec.description;
+    pkg.bin = { [bin]: './dist/main.js' };
+    pkg.files = ['dist'];
+    pkg.scripts = scripts;
+    pkg.dependencies = dependencies;
+    pkg.devDependencies = {
+        '@jest/globals': '^30.2.0',
+        '@types/node': '^25.5.2',
+        jest: '^30.2.0',
+        '@powerhousedao/ph-clint-dev': PH_CLINT_VERSION,
+        'ts-jest': '^29.4.6',
+        tsx: '^4.19.0',
+        typescript: '^6.0.2',
+        'typescript-eslint': '^8.33.0',
+    };
+    pkg.engines = { node: '>=22.13.0' };
+    return JSON.stringify(pkg, null, 2) + '\n';
+}

package/dist/codegen/builders/index.d.ts

@@ -1 +1,52 @@
-export { type FileBuilder, CLI_FILE_BUILDERS, getProfileFileBuilders, buildCliPackageJson, buildCliTs, buildConfigTs, buildMainTs, buildTsconfigJson, buildJestConfigJs, buildEslintConfigJs, buildGitignore, buildMastraIndexTs, buildBuildSkillsScript, buildAgentBaseMd, buildAgentTs, buildDemoAgentTs, buildFrameworkGenTs, buildFrameworkTs, buildManifestJson, buildSmokeTestTs, buildRootPackageJson, buildPublishConfigJs, buildReadme, buildAppIndexTs, } from '@powerhousedao/ph-clint-dev/codegen/builders';
+/**
+ * Registry of file builders. Each entry knows its own relative path (within
+ * the CLI sub-tree) and a function that builds its content from the spec.
+ *
+ * Orchestrated by `codegen/index.ts` — it walks this registry, adjusts paths
+ * for flat vs split layouts, and writes the files.
+ */
+import { buildCliPackageJson } from './cli-package-json.js';
+import { buildCliTs } from './cli-ts.js';
+import { buildConfigTs } from './config-ts.js';
+import { buildMainTs } from './main-ts.js';
+import { buildTsconfigJson } from './tsconfig-json.js';
+import { buildJestConfigJs } from './jest-config-js.js';
+import { buildEslintConfigJs } from './eslint-config-js.js';
+import { buildGitignore } from './gitignore.js';
+import { buildMastraIndexTs } from './mastra-index-ts.js';
+import { buildBuildSkillsScript } from './build-skills-ts.js';
+import { buildAgentBaseMd } from './agent-base-md.js';
+import { buildAgentTs } from './agent-ts.js';
+import { buildDemoAgentTs } from './demo-agent-ts.js';
+import { buildFrameworkGenTs } from './framework-gen-ts.js';
+import { buildFrameworkTs } from './framework-ts.js';
+import { buildManifestJson } from './manifest-json.js';
+import { buildSmokeTestTs } from './smoke-test-ts.js';
+import { type ClintProjectSpec } from '../../spec/types.js';
+/**
+ * A spec-driven file builder. Returns `null` from `build` to indicate the
+ * file should not be emitted for the given spec.
+ */
+export interface FileBuilder {
+    /** Path relative to the CLI root (flat or `{name}-cli/`). */
+    relativePath: string;
+    build(spec: ClintProjectSpec): string | null;
+    /**
+     * When true, this file is only emitted on `mode: 'create'`. In `update`
+     * mode the planner ignores the builder entirely, leaving any on-disk
+     * version untouched regardless of hash state. Used for files that carry
+     * user-owned hand edits (e.g. `src/framework.ts`'s `configSchema`).
+     */
+    initOnly?: boolean;
+}
+/**
+ * Generate dynamic file builders for agent profile markdown files.
+ * One file per profile in `prompts/agent-profiles/{id}.md`.
+ */
+export declare function getProfileFileBuilders(spec: ClintProjectSpec): FileBuilder[];
+export declare const CLI_FILE_BUILDERS: FileBuilder[];
+export { buildCliPackageJson, buildCliTs, buildConfigTs, buildMainTs, buildTsconfigJson, buildJestConfigJs, buildEslintConfigJs, buildGitignore, buildMastraIndexTs, buildBuildSkillsScript, buildAgentBaseMd, buildAgentTs, buildDemoAgentTs, buildFrameworkGenTs, buildFrameworkTs, buildManifestJson, buildSmokeTestTs, };
+export { buildRootPackageJson } from './root-package-json.js';
+export { buildPublishConfigJs } from './publish-config-js.js';
+export { buildReadme } from './readme-md.js';
+export { buildAppIndexTs } from './app-index-ts.js';