@powerhousedao/ph-clint-cli 0.1.0-dev.5 → 0.1.0-dev.51

package/dist/codegen/index.d.ts

@@ -1,4 +1,5 @@
 import { type ClintProjectSpec } from '../spec/types.js';
+import { type PostGenAction } from './actions.js';
 export type GenerateMode = 'create' | 'update' | 'auto';
 export interface GenerateProjectOptions {
     /** Absolute path to the project root. */
@@ -32,6 +33,8 @@ export interface GenerateProjectResult {
     migrated: boolean;
     cliDir: string;
     appDir: string | null;
+    /** Pending post-generation actions derived from what changed. */
+    pendingActions: PostGenAction[];
 }
 /**
  * Generate / reconcile a project at `targetDir` from the given spec.

package/dist/codegen/index.js

@@ -35,7 +35,10 @@ 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, buildReadme, buildRootPackageJson, buildAppIndexTs, } from './builders/index.js';
+import { CLI_FILE_BUILDERS, getProfileFileBuilders, buildReadme, buildRootPackageJson, buildPublishConfigJs, buildAppIndexTs, } 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.
  */
@@ -47,18 +50,24 @@ export async function generateProject(options) {
     // 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' &&
-        existingSpec &&
-        !existingSpec.features.powerhouse.enabled &&
-        spec.features.powerhouse.enabled) {
-        await migrateFlatToSplit({
-            targetDir,
-            spec,
-            force: options.force,
-            onWarn: warn,
-        });
-        migrated = true;
+    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') {
@@ -75,11 +84,12 @@ function resolveMode(requested, specExists) {
 }
 /** Build the list of files the new spec would emit, with their content. */
 function planFiles(spec, targetDir) {
-    const split = spec.features.powerhouse.enabled;
+    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 = [];
-    for (const builder of CLI_FILE_BUILDERS) {
+    const allBuilders = [...CLI_FILE_BUILDERS, ...getProfileFileBuilders(spec)];
+    for (const builder of allBuilders) {
         const content = builder.build(spec);
         if (content === null)
             continue;
@@ -98,6 +108,13 @@ function planFiles(spec, targetDir) {
         absolutePath: readmeAbs,
         content: buildReadme(spec),
     });
+    // 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');
@@ -147,6 +164,82 @@ function buildAppReadmeContent(spec) {
         '',
     ].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;
@@ -170,7 +263,9 @@ async function runCreate(options, _warn) {
         relativePath: path.relative(targetDir, getSpecPath(targetDir)),
     });
     await writeHashes(targetDir, hashes);
-    return {
+    // 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: [],
@@ -178,12 +273,18 @@ async function runCreate(options, _warn) {
         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);
@@ -195,13 +296,20 @@ async function runUpdate(options, warn, migrated) {
     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
-            // and never re-create them if missing — the user may have deliberately
-            // deleted or inlined them. Keep whatever hash the previous run stored
-            // so the deletion pass (step 2) still considers them "ours".
-            const stored = previous[p.relativePath];
-            if (stored !== undefined)
-                next[p.relativePath] = stored;
+            // 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);
@@ -280,7 +388,27 @@ async function runUpdate(options, warn, migrated) {
     }
     await writeProjectSpec(targetDir, spec);
     await writeHashes(targetDir, next);
-    return {
+    // 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,
@@ -288,5 +416,8 @@ async function runUpdate(options, warn, migrated) {
         migrated,
         cliDir,
         appDir,
+        pendingActions: [],
     };
+    result.pendingActions = await collectPostGenActions(result, spec);
+    return result;
 }

package/dist/codegen/scaffold.d.ts

@@ -1,4 +1,12 @@
 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 interface PhInitOptions {
     /** Absolute path to the project root. */
     targetDir: string;
@@ -9,22 +17,51 @@ export interface PhInitOptions {
     log?: (msg: string) => void;
     /** Override `ph` binary name (for tests). */
     binName?: string;
-    /** Stdio passthrough (tests pass 'ignore'). */
-    stdio?: 'inherit' | 'ignore';
+    /** Subprocess runner — uses CommandContext.runProcess when available. */
+    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;
-    stdio?: 'inherit' | 'ignore';
+    /** Subprocess runner — uses CommandContext.runProcess when available. */
+    runProcess?: RunProcess;
 }
 export interface PnpmInstallResult {
     ran: string[];
@@ -32,3 +69,4 @@ export interface PnpmInstallResult {
     reason?: string;
 }
 export declare function runPnpmInstall(options: PnpmInstallOptions): Promise<PnpmInstallResult>;
+export {};

package/dist/codegen/scaffold.js

@@ -7,33 +7,145 @@
  */
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { hasCommandOnPath, runCommand } from './exec.js';
+import { execFileSync } from 'node:child_process';
+import { hasCommandOnPath } from './exec.js';
+/**
+ * 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 function getPhVersion(binName) {
+    try {
+        const output = execFileSync(binName, ['--version'], {
+            encoding: 'utf-8',
+            timeout: 5_000,
+        });
+        const match = output.match(/PH CMD version:\s*(\S+)/);
+        return match?.[1];
+    }
+    catch {
+        return undefined;
+    }
+}
 export async function runPhInit(options) {
     const log = options.log ?? (() => { });
     const binName = options.binName ?? 'ph';
     const appFolder = path.basename(options.appDir);
+    // Guard: never re-init an already-initialized app directory.
+    try {
+        await fs.access(path.join(options.appDir, 'package.json'));
+        log(`App directory ${appFolder} already initialized — skipping ph init.`);
+        return { ran: false, reason: 'already-initialized' };
+    }
+    catch {
+        // No package.json — proceed with init.
+    }
     if (!(await hasCommandOnPath(binName))) {
         log(`Skipping \`${binName} init\` — \`${binName}\` is not on PATH. ` +
             `Install @powerhousedao/ph-cli and re-run manually inside ${appFolder}/.`);
         return { ran: false, reason: 'ph-not-on-path' };
     }
+    // Pin ph init to the same version as the installed ph CLI, so the
+    // generated app uses matching Powerhouse packages.
+    const phVersion = options.phVersion ?? getPhVersion(binName);
+    const tags = ['dev', 'staging', 'latest'];
+    const versionArgs = phVersion
+        ? tags.includes(phVersion)
+            ? [`--${phVersion}`]
+            : ['--version', phVersion]
+        : ['--dev']; // fallback if detection fails
     // `ph init {name}` creates a fresh directory beside the cwd. Our generator
     // placed a `.gitkeep` + README.md placeholder there; clear it out so
     // ph init has a blank slate to work with.
     await fs.rm(options.appDir, { recursive: true, force: true });
-    log(`Running \`${binName} init ${appFolder}\` in ${options.targetDir} …`);
-    const result = await runCommand(binName, [
-        'init',
-        appFolder,
-        '--pnpm',
-        '--dev',
-    ], { cwd: options.targetDir, stdio: options.stdio ?? 'inherit' });
+    const args = ['init', appFolder, ...versionArgs, '--pnpm'];
+    log(`Running \`${binName} init ${appFolder}\` (version: ${phVersion ?? 'auto'}) in ${options.targetDir} …`);
+    const run = options.runProcess;
+    if (run) {
+        const result = await run(`${binName} ${args.join(' ')}`, {
+            cwd: options.targetDir,
+            timeout: 300_000, // ph init + pnpm install can be slow
+        });
+        const exitCode = result.success ? 0 : 1;
+        if (!result.success) {
+            log(`\`${binName} init\` failed. ` +
+                'You can re-run it manually after resolving the issue.');
+        }
+        // Patch scoped name
+        await patchScopedName(options, appFolder, log);
+        return { ran: true, exitCode };
+    }
+    // Fallback: direct spawn with stdio inherit (for backward compat / tests without context)
+    const { runCommand } = await import('./exec.js');
+    const result = await runCommand(binName, args, { cwd: options.targetDir, stdio: 'inherit' });
     if (result.exitCode !== 0) {
         log(`\`${binName} init\` exited with code ${result.exitCode}. ` +
             'You can re-run it manually after resolving the issue.');
     }
+    await patchScopedName(options, appFolder, log);
     return { ran: true, exitCode: result.exitCode };
 }
+/**
+ * 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 async function patchAppPackageName(appDir, spec, log) {
+    const appFolder = path.basename(appDir);
+    const scopedName = spec.scope
+        ? `${spec.scope}/${appFolder}`
+        : appFolder;
+    const appPkgJsonPath = path.join(appDir, 'package.json');
+    try {
+        const raw = await fs.readFile(appPkgJsonPath, 'utf8');
+        const pkg = JSON.parse(raw);
+        if (pkg.name !== scopedName) {
+            pkg.name = scopedName;
+            if (spec.scope) {
+                pkg.publishConfig = { access: 'public' };
+            }
+            await fs.writeFile(appPkgJsonPath, JSON.stringify(pkg, null, 2) + '\n');
+            log?.(`Patched app package name to ${scopedName}`);
+            return true;
+        }
+        return false;
+    }
+    catch (err) {
+        log?.(`Warning: could not patch app package name: ${err instanceof Error ? err.message : String(err)}`);
+        return false;
+    }
+}
+async function patchScopedName(options, _appFolder, log) {
+    await patchAppPackageName(options.appDir, options.spec, log);
+}
+/**
+ * Run `ph install <packages> --local --pnpm` in the app directory to register
+ * external packages in `powerhouse.config.json`.
+ */
+export async function runPhInstallPackages(options) {
+    const { appDir, packages, log = () => { }, runProcess } = options;
+    const binName = 'ph';
+    if (!(await hasCommandOnPath(binName))) {
+        log(`Skipping — \`${binName}\` is not on PATH.`);
+        return false;
+    }
+    const args = ['install', ...packages, '--local', '--pnpm'];
+    log(`Running \`${binName} install ${packages.join(' ')} --local\` in ${path.basename(appDir)} …`);
+    if (runProcess) {
+        const result = await runProcess(`${binName} ${args.join(' ')}`, {
+            cwd: appDir,
+            timeout: 300_000,
+        });
+        return result.success;
+    }
+    const { runCommand } = await import('./exec.js');
+    const result = await runCommand(binName, args, {
+        cwd: appDir,
+        stdio: 'inherit',
+    });
+    return result.exitCode === 0;
+}
 export async function runPnpmInstall(options) {
     const log = options.log ?? (() => { });
     const binName = options.binName ?? 'pnpm';
@@ -45,14 +157,27 @@ export async function runPnpmInstall(options) {
     const ran = [];
     for (const dir of options.dirs) {
         log(`Running \`${binName} install\` in ${dir} …`);
-        const result = await runCommand(binName, ['install'], {
-            cwd: dir,
-            stdio: options.stdio ?? 'inherit',
-        });
-        if (result.exitCode !== 0) {
-            log(`\`${binName} install\` exited with code ${result.exitCode} in ${dir}. ` +
-                'Retry manually once the underlying issue is resolved.');
-            // Don't abort the whole chain — subsequent dirs may still work.
+        const run = options.runProcess;
+        if (run) {
+            const result = await run(`${binName} install`, {
+                cwd: dir,
+                timeout: 300_000,
+            });
+            if (!result.success) {
+                log(`\`${binName} install\` failed in ${dir}. ` +
+                    'Retry manually once the underlying issue is resolved.');
+            }
+        }
+        else {
+            const { runCommand } = await import('./exec.js');
+            const result = await runCommand(binName, ['install'], {
+                cwd: dir,
+                stdio: 'inherit',
+            });
+            if (result.exitCode !== 0) {
+                log(`\`${binName} install\` exited with code ${result.exitCode} in ${dir}. ` +
+                    'Retry manually once the underlying issue is resolved.');
+            }
         }
         ran.push(dir);
     }

package/dist/commands/clint-project-build.js

@@ -1,5 +1,4 @@
 import path from 'node:path';
-import { spawn } from 'node:child_process';
 import { defineCommand } from '@powerhousedao/ph-clint';
 import { z } from 'zod';
 import { detectLayout } from '@powerhousedao/ph-clint-dev';
@@ -7,44 +6,28 @@ const inputSchema = z.object({
     dir: z.string().optional().describe('Project root directory (default: cwd)'),
     verbose: z.boolean().default(false),
 });
-function execInDir(dir, cmd, verbose) {
-    return new Promise((resolve, reject) => {
-        const proc = spawn(cmd, {
-            cwd: dir,
-            shell: true,
-            stdio: verbose ? 'inherit' : 'pipe',
-        });
-        let stderr = '';
-        if (!verbose && proc.stderr) {
-            proc.stderr.on('data', (data) => {
-                stderr += data.toString();
-            });
-        }
-        proc.on('close', (code) => {
-            if (code === 0)
-                resolve();
-            else
-                reject(new Error(`Command "${cmd}" failed in ${dir} (exit ${code})${stderr ? `:\n${stderr}` : ''}`));
-        });
-        proc.on('error', (err) => reject(err));
-    });
-}
 export const build = defineCommand({
     id: 'clint-project-build',
     description: 'Build all packages in the project',
     inputSchema,
-    execute: async (input, { workdir, stdout }) => {
+    execute: async (input, { workdir, stdout, runProcess }) => {
         const dir = path.resolve(input.dir ?? workdir);
         const layout = detectLayout(dir);
         if (layout?.type === 'split') {
             stdout(`Building app package (${layout.app})...\n`);
-            await execInDir(layout.app, 'pnpm build', input.verbose);
+            const appResult = await runProcess('pnpm build', { cwd: layout.app, timeout: 120_000 });
+            if (!appResult.success)
+                return { text: `App build failed.` };
             stdout(`Building cli package (${layout.cli})...\n`);
-            await execInDir(layout.cli, 'pnpm build', input.verbose);
+            const cliResult = await runProcess('pnpm build', { cwd: layout.cli, timeout: 120_000 });
+            if (!cliResult.success)
+                return { text: `CLI build failed.` };
         }
         else {
             stdout(`Building project...\n`);
-            await execInDir(layout?.cli ?? dir, 'pnpm build', input.verbose);
+            const result = await runProcess('pnpm build', { cwd: layout?.cli ?? dir, timeout: 120_000 });
+            if (!result.success)
+                return { text: `Build failed.` };
         }
         return { text: 'Build complete.' };
     },

package/dist/commands/clint-project-init.d.ts

@@ -8,7 +8,6 @@ declare const inputSchema: z.ZodObject<{
     enableMastra: z.ZodDefault<z.ZodBoolean>;
     enableRoutine: z.ZodDefault<z.ZodBoolean>;
     force: z.ZodDefault<z.ZodBoolean>;
-    skipPhInit: z.ZodDefault<z.ZodBoolean>;
     skipInstall: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 type InitInput = z.output<typeof inputSchema>;
@@ -21,7 +20,6 @@ export declare const init: import("@powerhousedao/ph-clint").Command<z.ZodObject
     enableMastra: z.ZodDefault<z.ZodBoolean>;
     enableRoutine: z.ZodDefault<z.ZodBoolean>;
     force: z.ZodDefault<z.ZodBoolean>;
-    skipPhInit: z.ZodDefault<z.ZodBoolean>;
     skipInstall: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>, {
     text: string;
@@ -35,21 +33,48 @@ export declare const init: import("@powerhousedao/ph-clint").Command<z.ZodObject
             version: string;
             description: string;
             features: {
-                powerhouse: {
-                    enabled: boolean;
-                    switchboard: boolean;
-                    connect: boolean;
-                };
+                powerhouse: "Disabled" | "Reactor" | "Switchboard" | "Connect";
                 mastra: {
                     enabled: boolean;
+                    agentId: string | null;
+                    agentName: string | null;
+                    agentDescription: string | null;
+                    agentImage: string | null;
+                    models: {
+                        id: string;
+                        isDefault: boolean;
+                    }[];
+                    profiles: {
+                        id: string;
+                        title: string;
+                        content: string;
+                    }[];
+                    common: {
+                        enableChat: boolean;
+                    };
                 };
                 routine: {
                     enabled: boolean;
                 };
             };
-            documentTypes: string[];
+            packages: {
+                id: string;
+                packageName: string;
+                documentTypes: string[];
+                version: string | null;
+            }[];
+            externalSkills: {
+                id: string;
+                name: string;
+                githubUrl: string;
+            }[];
+            deployment: {
+                proxyEnabled: boolean;
+                supportedResources: string[];
+            };
             scope?: string | undefined;
-            bin?: string | undefined;
+            documentId?: string | undefined;
+            documentType?: string | undefined;
         };
         fileCount: number;
     };