@powerhousedao/ph-clint-cli 0.1.0-dev.95 → 0.1.0-dev.97

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powerhousedao/ph-clint-cli",
-  "version": "0.1.0-dev.95",
+  "version": "0.1.0-dev.97",
   "publishConfig": {
     "access": "public"
   },
@@ -12,33 +12,21 @@
   "files": [
     "dist"
   ],
-  "scripts": {
-    "build:skills": "tsx scripts/build-skills.ts",
-    "build": "pnpm build:skills && tsc",
-    "dev": "tsx src/main.ts",
-    "start": "node dist/main.js",
-    "test": "NODE_OPTIONS='--experimental-vm-modules' jest --detectOpenHandles --coverage",
-    "test:e2e": "NODE_OPTIONS='--experimental-vm-modules' jest --detectOpenHandles --testPathPatterns 'tests/(e2e|codegen-e2e)/' --testPathIgnorePatterns '/node_modules/'",
-    "lint": "eslint src",
-    "mastra:dev": "mastra dev",
-    "mastra:build": "mastra build",
-    "mastra:start": "mastra start"
-  },
   "dependencies": {
     "@electric-sql/pglite": "0.3.15",
-    "@mastra/core": "1.41.0",
-    "@mastra/libsql": "1.12.1",
-    "@mastra/memory": "1.20.2",
-    "@powerhousedao/ph-clint": "0.1.0-dev.95",
-    "@powerhousedao/ph-clint-app": "0.1.0-dev.95",
-    "@powerhousedao/ph-clint-dev": "0.1.0-dev.95",
-    "@powerhousedao/reactor": "6.2.0-dev.23",
-    "@powerhousedao/reactor-api": "6.2.0-dev.23",
-    "@powerhousedao/shared": "6.2.0-dev.23",
-    "document-model": "6.2.0-dev.23",
+    "@mastra/core": "^1.41.0",
+    "@mastra/libsql": "^1.12.1",
+    "@mastra/memory": "^1.20.2",
+    "@powerhousedao/reactor": "6.2.0-rc.2",
+    "@powerhousedao/reactor-api": "6.2.0-rc.2",
+    "@powerhousedao/shared": "6.2.0-rc.2",
+    "document-model": "6.2.0-rc.2",
     "kysely": "^0.27.0",
     "kysely-pglite-dialect": "^1.3.0",
-    "zod": "4.3.6"
+    "zod": "4.3.6",
+    "@powerhousedao/ph-clint": "0.1.0-dev.97",
+    "@powerhousedao/ph-clint-dev": "0.1.0-dev.97",
+    "@powerhousedao/ph-clint-app": "0.1.0-dev.97"
   },
   "devDependencies": {
     "@jest/globals": "^30.2.0",
@@ -50,5 +38,17 @@
   },
   "engines": {
     "node": ">=22.13.0"
+  },
+  "scripts": {
+    "build:skills": "tsx scripts/build-skills.ts",
+    "build": "pnpm build:skills && tsc",
+    "dev": "tsx src/main.ts",
+    "start": "node dist/main.js",
+    "test": "NODE_OPTIONS='--experimental-vm-modules' jest --detectOpenHandles --coverage",
+    "test:e2e": "NODE_OPTIONS='--experimental-vm-modules' jest --detectOpenHandles --testPathPatterns 'tests/(e2e|codegen-e2e)/' --testPathIgnorePatterns '/node_modules/'",
+    "lint": "eslint src",
+    "mastra:dev": "mastra dev",
+    "mastra:build": "mastra build",
+    "mastra:start": "mastra start"
   }
-}
+}

package/dist/codegen/actions.d.ts

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

package/dist/codegen/actions.js

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

package/dist/codegen/builders/agent-base-md.d.ts

@@ -1,5 +0,0 @@
-/**
- * Builds `prompts/agent-profiles/AgentBase.md` — the minimal base profile.
- */
-import { type ClintProjectSpec } from '../../spec/types.js';
-export declare function buildAgentBaseMd(spec: ClintProjectSpec): string;

package/dist/codegen/builders/agent-base-md.js

@@ -1,18 +0,0 @@
-/**
- * Builds `prompts/agent-profiles/AgentBase.md` — the minimal base profile.
- */
-import { getPackageName, } from '../../spec/types.js';
-export function buildAgentBaseMd(spec) {
-    return [
-        '# Agent Base System Prompt',
-        '',
-        `You are {{agentName}}, an agent available through the ${getPackageName(spec)} CLI.`,
-        '',
-        '## Capabilities',
-        '',
-        'This base profile is a minimal placeholder. Extend it with project-specific',
-        "context, workflows, and domain knowledge. Additional sections listed in the",
-        "agent's `sections` array are concatenated after this file at build time.",
-        '',
-    ].join('\n');
-}

package/dist/codegen/builders/agent-ts.d.ts

@@ -1,9 +0,0 @@
-/**
- * Builds `src/agents/agent.ts` — a Mastra agent factory.
- *
- * Emitted only when `features.mastra.enabled`. When the spec includes agent
- * config (agentId, models, profiles), generates a real `@mastra/core` Agent.
- * Otherwise falls back to a deterministic echo-style demo provider.
- */
-import { type ClintProjectSpec } from '../../spec/types.js';
-export declare function buildAgentTs(spec: ClintProjectSpec): string;