@powerhousedao/ph-clint-cli 0.1.0-dev.33 → 0.1.0-dev.35

package/dist/codegen/actions.d.ts

@@ -0,0 +1,42 @@
+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-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

@@ -0,0 +1,372 @@
+/**
+ * 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';
+// ---------------------------------------------------------------------------
+// Fixed execution order — index defines precedence
+// ---------------------------------------------------------------------------
+const ACTION_ORDER = [
+    'ph-init',
+    'app-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-build → cli-install → cli-build
+    // skills-sync is independent of the build chain
+    const chain = [
+        'ph-init',
+        'app-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;
+    }
+}
+// ---------------------------------------------------------------------------
+// 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')) {
+                    earliest = 'cli-build';
+                    break;
+                }
+            }
+        }
+    }
+    // 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-build')) {
+            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')) {
+            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')) {
+            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-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-build
+        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-install':
+        case 'cli-install': {
+            if (ctx.runProcess) {
+                const result = await ctx.runProcess('pnpm install', {
+                    cwd: action.dir,
+                    timeout: 300_000,
+                });
+                return result.success;
+            }
+            // Fallback: direct spawn
+            const { runCommand } = await import('./exec.js');
+            const result = await runCommand('pnpm', ['install'], {
+                cwd: action.dir,
+                stdio: 'inherit',
+            });
+            return result.exitCode === 0;
+        }
+        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) {
+    if (ctx.runProcess) {
+        const result = await ctx.runProcess('pnpm build', {
+            cwd: dir,
+            timeout: 120_000,
+        });
+        return result.success;
+    }
+    // Fallback: direct spawn
+    const { runCommand } = await import('./exec.js');
+    const result = await runCommand('pnpm', ['build'], {
+        cwd: dir,
+        stdio: 'inherit',
+    });
+    return result.exitCode === 0;
+}
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    return `${(ms / 1000).toFixed(1)}s`;
+}

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

@@ -36,6 +36,7 @@ export function buildRootPackageJson(spec) {
         name: getPackageName(spec),
         version: spec.version,
         private: true,
+        type: 'module',
         ...(spec.description ? { description: spec.description } : {}),
         scripts,
     };

package/dist/codegen/generated.d.ts

@@ -0,0 +1,17 @@
+import { type ClintProjectSpec } from '../spec/types.js';
+export interface GeneratedState {
+    name: string;
+    scope: string | undefined;
+    cliFolderName: string;
+    appFolderName: string;
+    /** True once `ph init` has run successfully in the app dir. */
+    appInitialized: boolean;
+}
+export declare function getGeneratedPath(targetDir: string): string;
+export declare function readGeneratedState(targetDir: string): Promise<GeneratedState | null>;
+export declare function writeGeneratedState(targetDir: string, state: GeneratedState): Promise<void>;
+/**
+ * Derive a `GeneratedState` from a spec. The `appInitialized` flag must be
+ * supplied by the caller (it depends on filesystem state, not the spec).
+ */
+export declare function generatedStateFromSpec(spec: ClintProjectSpec, appInitialized: boolean): GeneratedState;

package/dist/codegen/generated.js

@@ -0,0 +1,49 @@
+/**
+ * Tracks the derived state from the last successful code generation.
+ *
+ * Stored at `{targetDir}/.ph/ph-clint-cli/generated.json`. Used to detect
+ * folder renames (name/scope changes) and re-apply patches that depend on
+ * the project identity.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getAppFolderName, getCliFolderName, } from '../spec/types.js';
+const GEN_DIR = path.join('.ph', 'ph-clint-cli');
+const GEN_FILE = 'generated.json';
+export function getGeneratedPath(targetDir) {
+    return path.join(targetDir, GEN_DIR, GEN_FILE);
+}
+export async function readGeneratedState(targetDir) {
+    try {
+        const raw = await fs.readFile(getGeneratedPath(targetDir), 'utf8');
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        if (err &&
+            typeof err === 'object' &&
+            'code' in err &&
+            err.code === 'ENOENT') {
+            return null;
+        }
+        throw err;
+    }
+}
+export async function writeGeneratedState(targetDir, state) {
+    const file = getGeneratedPath(targetDir);
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    await fs.writeFile(file, JSON.stringify(state, null, 2) + '\n', 'utf8');
+}
+/**
+ * Derive a `GeneratedState` from a spec. The `appInitialized` flag must be
+ * supplied by the caller (it depends on filesystem state, not the spec).
+ */
+export function generatedStateFromSpec(spec, appInitialized) {
+    const split = spec.features.powerhouse !== 'Disabled';
+    return {
+        name: spec.name,
+        scope: spec.scope,
+        cliFolderName: split ? getCliFolderName(spec) : '',
+        appFolderName: split ? getAppFolderName(spec) : '',
+        appInitialized,
+    };
+}

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

@@ -36,6 +36,9 @@ 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, 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.
  */
@@ -155,6 +158,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;
@@ -178,7 +257,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: [],
@@ -186,12 +267,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);
@@ -295,7 +382,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,
@@ -303,5 +410,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

@@ -34,6 +34,16 @@ export interface PhInitResult {
  */
 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>;
 export interface PnpmInstallOptions {
     /** Directories to run `pnpm install` in, in order. */
     dirs: string[];

package/dist/codegen/scaffold.js

@@ -31,6 +31,15 @@ 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}/.`);
@@ -76,25 +85,40 @@ export async function runPhInit(options) {
     await patchScopedName(options, appFolder, log);
     return { ran: true, exitCode: result.exitCode };
 }
-async function patchScopedName(options, appFolder, log) {
-    if (!options.spec.scope)
-        return;
-    const appPkgJsonPath = path.join(options.appDir, 'package.json');
+/**
+ * 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);
-        const scopedName = `@${options.spec.scope}/${appFolder}`;
         if (pkg.name !== scopedName) {
             pkg.name = scopedName;
-            pkg.publishConfig = { access: 'public' };
+            if (spec.scope) {
+                pkg.publishConfig = { access: 'public' };
+            }
             await fs.writeFile(appPkgJsonPath, JSON.stringify(pkg, null, 2) + '\n');
-            log(`Patched app package name to ${scopedName}`);
+            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)}`);
+        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);
+}
 export async function runPnpmInstall(options) {
     const log = options.log ?? (() => { });
     const binName = options.binName ?? 'pnpm';

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

@@ -18,7 +18,7 @@ import { z } from 'zod';
 import { clintProjectSpecSchema, } from '../spec/types.js';
 import { generateProject } from '../codegen/index.js';
 import { isDirEmptyEnough } from '../codegen/write.js';
-import { runPhInit, runPnpmInstall } from '../codegen/scaffold.js';
+import { runPostGenActions } from '../codegen/actions.js';
 import { writeProjectSpec } from '../spec/file.js';
 import { specToImportInput } from '../triggers/spec-change.js';
 const inputSchema = z.object({
@@ -143,37 +143,20 @@ export const init = defineCommand({
                 stdout(`Note: could not create spec document — ${err instanceof Error ? err.message : String(err)}\n`);
             }
         }
-        const split = spec.features.powerhouse !== 'Disabled';
-        // Reactor package scaffolding (split layout only).
-        if (split && result.appDir && !input.skipPhInit) {
-            const phResult = await runPhInit({
-                targetDir,
-                appDir: result.appDir,
-                spec,
-                log: (msg) => stdout(msg + '\n'),
-                runProcess,
-            });
-            if (!phResult.ran) {
-                stdout(`Note: \`ph init\` did not run — ${phResult.reason ?? 'see above'}.\n`);
-            }
-        }
-        // Dependency installation.
-        if (!input.skipInstall) {
-            const dirs = [];
-            if (split) {
-                if (result.appDir)
-                    dirs.push(result.appDir);
-                dirs.push(result.cliDir);
-            }
-            else {
-                dirs.push(targetDir);
-            }
-            await runPnpmInstall({
-                dirs,
-                log: (msg) => stdout(msg + '\n'),
-                runProcess,
-            });
+        // Run post-generation actions (ph-init, install, build, skills-sync).
+        const skip = new Set();
+        if (input.skipPhInit)
+            skip.add('ph-init');
+        if (input.skipInstall) {
+            skip.add('app-install');
+            skip.add('cli-install');
         }
+        await runPostGenActions(result.pendingActions, {
+            log: (msg) => stdout(msg + '\n'),
+            runProcess,
+            skip,
+        });
+        const split = spec.features.powerhouse !== 'Disabled';
         const next = [];
         next.push('');
         next.push('Next steps:');

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

@@ -11,6 +11,7 @@ import { defineCommand } from '@powerhousedao/ph-clint';
 import { z } from 'zod';
 import { readProjectSpec } from '../spec/file.js';
 import { generateProject } from '../codegen/index.js';
+import { runPostGenActions } from '../codegen/actions.js';
 const inputSchema = z.object({
     dir: z
         .string()
@@ -25,7 +26,7 @@ export const regen = defineCommand({
     id: 'clint-project-regen',
     description: 'Regenerate project files from the persisted spec',
     inputSchema,
-    execute: async (input, { workdir, stdout, log }) => {
+    execute: async (input, { workdir, stdout, log, runProcess }) => {
         const targetDir = path.resolve(workdir, input.dir ?? '.');
         const spec = await readProjectSpec(targetDir);
         if (!spec) {
@@ -53,6 +54,11 @@ export const regen = defineCommand({
                 stdout('warning: ' + w + '\n');
         }
         stdout(lines.join('\n') + '\n');
+        // Run post-generation actions (install, build, skills-sync).
+        await runPostGenActions(result.pendingActions, {
+            log: (msg) => stdout(msg + '\n'),
+            runProcess,
+        });
         return {
             text: lines.join('\n'),
             data: {

package/dist/triggers/spec-change.js

@@ -20,10 +20,9 @@ import { scanProjects, getProjectMapping } from '@powerhousedao/ph-clint';
 import { importSpec } from '@powerhousedao/ph-clint-app/document-models/ph-clint-project';
 import { createDocumentChangeTrigger } from '../framework.js';
 import { generateProject } from '../codegen/index.js';
-import { runPhInit } from '../codegen/scaffold.js';
+import { runPostGenActions } from '../codegen/actions.js';
 import { specFromDocumentState } from '../spec/from-document.js';
 import { readProjectSpec, writeProjectSpec } from '../spec/file.js';
-import { syncExternalSkills } from '../skills/sync.js';
 import { clintProject } from '../services/clint-project.js';
 const DOCUMENT_TYPE = 'powerhouse/ph-clint-project';
 const HASH_DIR = path.join('.ph', 'ph-clint-cli');
@@ -184,62 +183,11 @@ export const specChangeTrigger = createDocumentChangeTrigger({
                 for (const w of warnings)
                     log.warn(`${TAG} ${w}`);
             }
-            // Scaffold the reactor package (app dir) if it hasn't been initialized yet.
-            if (result.appDir) {
-                const appPkgJson = path.join(result.appDir, 'package.json');
-                let appExists = false;
-                try {
-                    await fs.access(appPkgJson);
-                    appExists = true;
-                }
-                catch { /* noop */ }
-                if (!appExists) {
-                    log?.info(`${TAG} initializing reactor package at ${result.appDir}`);
-                    const phResult = await runPhInit({
-                        targetDir,
-                        appDir: result.appDir,
-                        spec,
-                        log: (msg) => log?.info(`${TAG} ${msg}`),
-                        runProcess: ctx.context.runProcess,
-                    });
-                    if (!phResult.ran) {
-                        log?.warn(`${TAG} ph init skipped: ${phResult.reason ?? 'unknown'}`);
-                    }
-                    else if (phResult.exitCode !== 0) {
-                        log?.warn(`${TAG} ph init exited with code ${phResult.exitCode}`);
-                    }
-                }
-                // Always ensure the app package name matches the spec's scope,
-                // even if ph init ran in a previous trigger cycle without scope.
-                if (spec.scope) {
-                    try {
-                        const raw = await fs.readFile(appPkgJson, 'utf8');
-                        const pkg = JSON.parse(raw);
-                        const appFolder = path.basename(result.appDir);
-                        const scopedName = `@${spec.scope}/${appFolder}`;
-                        if (pkg.name !== scopedName) {
-                            pkg.name = scopedName;
-                            pkg.publishConfig = { access: 'public' };
-                            await fs.writeFile(appPkgJson, JSON.stringify(pkg, null, 2) + '\n');
-                            log?.info(`${TAG} patched app package name to ${scopedName}`);
-                        }
-                    }
-                    catch (err) {
-                        log?.warn(`${TAG} could not patch app package name: ${err instanceof Error ? err.message : String(err)}`);
-                    }
-                }
-            }
-            // Sync external skills after codegen.
-            if (spec.externalSkills.length > 0) {
-                const skillsResult = await syncExternalSkills({
-                    targetDir,
-                    desired: spec.externalSkills,
-                    log: (msg) => log?.info(`${TAG} ${msg}`),
-                });
-                if (log && (skillsResult.added.length > 0 || skillsResult.removed.length > 0)) {
-                    log.info(`${TAG} skills sync: +${skillsResult.added.length} -${skillsResult.removed.length}`);
-                }
-            }
+            // Run post-generation actions (ph-init, install, build, skills-sync).
+            await runPostGenActions(result.pendingActions, {
+                log: (msg) => log?.info(`${TAG} ${msg}`),
+                runProcess: ctx.context.runProcess,
+            });
         }
         // Work done inline, no additional work item needed
         return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powerhousedao/ph-clint-cli",
-  "version": "0.1.0-dev.33",
+  "version": "0.1.0-dev.35",
   "publishConfig": {
     "access": "public"
   },
@@ -29,9 +29,9 @@
     "@mastra/core": "^1.22.0",
     "@mastra/libsql": "^1.7.4",
     "@mastra/memory": "^1.13.1",
-    "@powerhousedao/ph-clint": "^0.1.0-dev.33",
-    "@powerhousedao/ph-clint-app": "^0.1.0-dev.33",
-    "@powerhousedao/ph-clint-dev": "^0.1.0-dev.33",
+    "@powerhousedao/ph-clint": "^0.1.0-dev.35",
+    "@powerhousedao/ph-clint-app": "^0.1.0-dev.35",
+    "@powerhousedao/ph-clint-dev": "^0.1.0-dev.35",
     "@powerhousedao/reactor": "6.0.0-dev.170",
     "@powerhousedao/reactor-api": "6.0.0-dev.170",
     "@powerhousedao/shared": "6.0.0-dev.170",