@powerhousedao/ph-clint-cli 0.1.0-dev.9 → 0.1.0-dev.90

package/dist/cli.js

@@ -7,7 +7,8 @@
  * Everything outside the markers is user-editable and preserved.
  */
 import path from 'node:path';
-import { defineCli, buildDefaultReactor } from '@powerhousedao/ph-clint';
+import { defineCli, buildDefaultReactor, deterministicId } from '@powerhousedao/ph-clint';
+import { z } from 'zod';
 import { CLI_NAME, CLI_VERSION, CLI_ROOT } from './config.js';
 import { configSchema, secretsSchema } from './framework.js';
 // @clint:begin imports
@@ -18,30 +19,69 @@ import { regen } from './commands/clint-project-regen.js';
 import { build } from './commands/clint-project-build.js';
 import { clintProjectPublish } from './commands/clint-project-publish.js';
 import { clintProject } from './services/clint-project.js';
+import { skillsSync } from './commands/clint-skills-sync.js';
 import { specChangeTrigger } from './triggers/spec-change.js';
+import { publishTrigger } from './triggers/publish-trigger.js';
 // @clint:end imports
-// Connect (ph connect) must run inside the Reactor Package (ph-clint-app).
-const appDir = path.resolve(CLI_ROOT, '../ph-clint-app');
 export const cli = defineCli({
     name: CLI_NAME,
     version: CLI_VERSION,
+    root: CLI_ROOT,
     description: `${CLI_NAME} v${CLI_VERSION} — scaffold and maintain ph-clint implementation projects`,
     configSchema,
     secretsSchema,
     // @clint:begin commands
-    commands: [init, regen, build, clintProjectPublish],
+    commands: [init, regen, build, clintProjectPublish, skillsSync],
     // @clint:end commands
     // @clint:begin services
     services: [clintProject],
     // @clint:end services
     // @clint:begin triggers
-    triggers: [specChangeTrigger],
+    triggers: [specChangeTrigger, publishTrigger],
+    routine: { id: 'triggers', name: 'Triggers' },
     // @clint:end triggers
     // @clint:begin prompts
     prompts: {
-        sources: [],
-        agents: {},
-        skills: {},
+        artifacts: [path.join(CLI_ROOT, 'gen', 'skills'), path.join(CLI_ROOT, 'dist', 'gen', 'skills')],
+        agents: {
+            'ph-clint-dev-agent': {
+                name: 'PhClintDevAgent',
+                sections: ['AgentBase.md'],
+                skills: ['cli-setup', 'command-definition', 'service-definition'],
+            },
+        },
+        skills: {
+            'cli-setup': {
+                description: 'Set up a new CLI with defineCli, config schemas, entrypoint, and interactive mode',
+                inputSchema: z.object({
+                    mode: z
+                        .enum(['expert', 'discovery', 'one-shot'])
+                        .default('expert')
+                        .describe('Expert: align design decisions with the developer. Discovery: explain concepts step by step. One-shot: make all decisions autonomously'),
+                }),
+                instructionTemplate: 'Use your {{skillId}} skill in {{mode}} mode for: {{prompt}}',
+            },
+            'command-definition': {
+                description: 'Define commands with Zod schemas, execute functions, return values, and parameter prompting',
+                inputSchema: z.object({
+                    mode: z
+                        .enum(['expert', 'discovery', 'one-shot'])
+                        .default('expert')
+                        .describe('Expert: align design decisions with the developer. Discovery: explain concepts step by step. One-shot: make all decisions autonomously'),
+                }),
+                instructionTemplate: 'Use your {{skillId}} skill in {{mode}} mode for: {{prompt}}',
+            },
+            'service-definition': {
+                description: 'Define background services with readiness detection, preflight checks, and project scanning',
+                inputSchema: z.object({
+                    mode: z
+                        .enum(['expert', 'discovery', 'one-shot'])
+                        .default('expert')
+                        .describe('Expert: align design decisions with the developer. Discovery: explain concepts step by step. One-shot: make all decisions autonomously'),
+                }),
+                instructionTemplate: 'Use your {{skillId}} skill in {{mode}} mode for: {{prompt}}',
+            },
+        },
     },
     // @clint:end prompts
     // @clint:begin events
@@ -68,11 +108,13 @@ export const cli = defineCli({
 cli.configureReactor({
     create: (ctx) => buildDefaultReactor(ctx, {
         documentModels,
-        drive: { name: 'Clint' },
+        drives: [
+            { name: 'Clint Folders', role: 'personal', id: deterministicId(CLI_NAME, 'personal-drive') },
+        ],
         subscriptions: { documentTypes: ['powerhouse/ph-clint-project'] },
     }),
     switchboard: { enabled: true },
-    connect: { enabled: true, workdir: appDir },
+    connect: { enabled: true },
 });
 // @clint:end reactor
 // @clint:begin mastra

package/dist/codegen/actions.d.ts

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

@@ -0,0 +1,424 @@
+/**
+ * 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-ts.d.ts

@@ -1,9 +1,9 @@
 /**
- * Builds `src/agents/agent.ts` — a minimal Mastra agent factory.
+ * Builds `src/agents/agent.ts` — a Mastra agent factory.
  *
- * Emitted only when `features.mastra.enabled`. The generated agent falls back
- * to a deterministic echo-style demo provider when no API key is configured,
- * so `pnpm dev` works immediately out of the box.
+ * 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;