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

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): PostGenAction[];
+export declare function runPostGenActions(actions: PostGenAction[], ctx: PostGenActionContext): Promise<PostGenActionResult[]>;

package/dist/codegen/actions.js

@@ -0,0 +1,342 @@
+/**
+ * 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 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;
+}
+// ---------------------------------------------------------------------------
+// collectPostGenActions — pure function
+// ---------------------------------------------------------------------------
+export 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 exists but no package.json (new scaffold)
+        const appPkgJsonChanged = relPaths.has(path.join(appFolder, 'package.json'));
+        // Check for the .gitkeep — signals a new app dir that needs ph-init
+        const appGitkeepWritten = relPaths.has(path.join(appFolder, '.gitkeep'));
+        if (appGitkeepWritten && !appPkgJsonChanged) {
+            // .gitkeep written but no package.json — app needs ph init
+            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 regenerated (.ts files)
+        if (!earliest) {
+            for (const rel of relPaths) {
+                if (rel.startsWith(cliFolder + '/') &&
+                    rel.endsWith('.ts')) {
+                    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;
+            }
+            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/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,7 @@ 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';
 /**
  * Generate / reconcile a project at `targetDir` from the given spec.
  */
@@ -178,7 +179,7 @@ async function runCreate(options, _warn) {
         relativePath: path.relative(targetDir, getSpecPath(targetDir)),
     });
     await writeHashes(targetDir, hashes);
-    return {
+    const result = {
         mode: 'create',
         files,
         skipped: [],
@@ -186,7 +187,10 @@ async function runCreate(options, _warn) {
         migrated: false,
         cliDir,
         appDir,
+        pendingActions: [],
     };
+    result.pendingActions = collectPostGenActions(result, spec);
+    return result;
 }
 /** Update mode — reconcile against an existing project. */
 async function runUpdate(options, warn, migrated) {
@@ -295,7 +299,7 @@ async function runUpdate(options, warn, migrated) {
     }
     await writeProjectSpec(targetDir, spec);
     await writeHashes(targetDir, next);
-    return {
+    const result = {
         mode: 'update',
         files,
         skipped,
@@ -303,5 +307,8 @@ async function runUpdate(options, warn, migrated) {
         migrated,
         cliDir,
         appDir,
+        pendingActions: [],
     };
+    result.pendingActions = collectPostGenActions(result, spec);
+    return result;
 }

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.34",
   "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.34",
+    "@powerhousedao/ph-clint-app": "^0.1.0-dev.34",
+    "@powerhousedao/ph-clint-dev": "^0.1.0-dev.34",
     "@powerhousedao/reactor": "6.0.0-dev.170",
     "@powerhousedao/reactor-api": "6.0.0-dev.170",
     "@powerhousedao/shared": "6.0.0-dev.170",