@powerhousedao/ph-clint-cli 0.1.0-dev.3 → 0.1.0-dev.31

package/dist/codegen/scaffold.js

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

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

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

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

@@ -35,21 +35,45 @@ export declare const init: import("@powerhousedao/ph-clint").Command<z.ZodObject
             version: string;
             description: string;
             features: {
-                powerhouse: {
-                    enabled: boolean;
-                    switchboard: boolean;
-                    connect: boolean;
-                };
+                powerhouse: "Disabled" | "Reactor" | "Switchboard" | "Connect";
                 mastra: {
                     enabled: boolean;
+                    agentId: string | null;
+                    agentName: string | null;
+                    agentDescription: string | null;
+                    agentImage: string | null;
+                    models: {
+                        id: string;
+                        isDefault: boolean;
+                    }[];
+                    profiles: {
+                        id: string;
+                        title: string;
+                        content: string;
+                    }[];
                 };
                 routine: {
                     enabled: boolean;
                 };
             };
-            documentTypes: string[];
+            packages: {
+                id: string;
+                packageName: string;
+                documentTypes: string[];
+            }[];
+            externalSkills: {
+                id: string;
+                name: string;
+                githubUrl: string;
+            }[];
+            deployment: {
+                serviceAnnouncement: boolean;
+                supportedResources: string[];
+            };
             scope?: string | undefined;
             bin?: string | undefined;
+            documentId?: string | undefined;
+            documentType?: string | undefined;
         };
         fileCount: number;
     };

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

@@ -1,8 +1,8 @@
 /**
- * `ph-clint init` — the project bootstrap wizard.
+ * `ph-clint clint-project-init` — the project bootstrap wizard.
  *
  * Behavior:
- *   1. Resolve target dir (positional `dir`, defaults to cwd).
+ *   1. Resolve target dir (positional `dir`, defaults to the project name).
  *   2. Assert it is empty (or `--force`).
  *   3. Collect project identity + feature toggles (prompt for missing).
  *   4. Assemble a ClintProjectSpec and validate with Zod.
@@ -13,16 +13,19 @@
  */
 import path from 'node:path';
 import { defineCommand } from '@powerhousedao/ph-clint';
+import { importSpec } from '@powerhousedao/ph-clint-app/document-models/ph-clint-project';
 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 { writeProjectSpec } from '../spec/file.js';
+import { specToImportInput } from '../triggers/spec-change.js';
 const inputSchema = z.object({
     dir: z
         .string()
         .optional()
-        .describe('Target directory (defaults to the current directory)'),
+        .describe('Target directory (defaults to the project name)'),
     name: z
         .string()
         .describe('Project name — bare, or `@scope/name`. Lowercase letters, digits, hyphens.'),
@@ -70,13 +73,22 @@ export function buildSpec(input) {
     // Routine is forced on when Mastra is on — the REPL-only path works, but
     // the agent routine loop is what most users actually want.
     const routine = input.enableRoutine || input.enableMastra;
+    const mastra = input.enableMastra
+        ? {
+            enabled: true,
+            agentId: `${name}-agent`,
+            agentName: `${name.charAt(0).toUpperCase()}${name.slice(1).replace(/-(\w)/g, (_, c) => ' ' + c.toUpperCase())} Agent`,
+            models: [{ id: 'anthropic/claude-sonnet-4-5', isDefault: true }],
+            profiles: [{ id: 'base', title: 'Base', content: 'You are a helpful assistant.' }],
+        }
+        : { enabled: false };
     const candidate = {
         name,
         scope,
         description: input.description ?? '',
         features: {
-            powerhouse: { enabled: input.enablePowerhouse },
-            mastra: { enabled: input.enableMastra },
+            powerhouse: input.enablePowerhouse ? 'Connect' : 'Disabled',
+            mastra,
             routine: { enabled: routine },
         },
     };
@@ -90,8 +102,9 @@ export const init = defineCommand({
         promptForDefaults: true,
         promptOptional: ['description'],
     },
-    execute: async (input, { workdir, stdout }) => {
-        const targetDir = path.resolve(workdir, input.dir ?? '.');
+    execute: async (input, { workdir, stdout, reactor: getReactor, folders, runProcess }) => {
+        const { name: bareName } = splitPackageName(input.name);
+        const targetDir = path.resolve(workdir, input.dir ?? bareName);
         if (!input.force) {
             const empty = await isDirEmptyEnough(targetDir);
             if (!empty) {
@@ -109,7 +122,28 @@ export const init = defineCommand({
             allowNonEmpty: input.force,
         });
         stdout(`Generated ${result.files.length} files in ${targetDir}\n`);
-        const split = spec.features.powerhouse.enabled;
+        // Create spec document in personal drive (if reactor available)
+        if (getReactor && folders) {
+            try {
+                const reactor = await getReactor();
+                if (reactor) {
+                    const newDoc = await reactor.client.createEmpty('powerhouse/ph-clint-project');
+                    const docId = newDoc.header.id;
+                    await folders.addDocument(docId, `specs/${spec.name}`, spec.name);
+                    const importInput = specToImportInput(spec);
+                    await reactor.client.execute(docId, 'main', [importSpec(importInput)]);
+                    spec.documentId = docId;
+                    spec.documentType = 'powerhouse/ph-clint-project';
+                    await writeProjectSpec(targetDir, spec);
+                    stdout(`Created spec document ${docId} in Clint Folders/specs/${spec.name}\n`);
+                }
+            }
+            catch (err) {
+                // Non-fatal — trigger will pick it up on next startup
+                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({
@@ -117,6 +151,7 @@ export const init = defineCommand({
                 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`);
@@ -136,6 +171,7 @@ export const init = defineCommand({
             await runPnpmInstall({
                 dirs,
                 log: (msg) => stdout(msg + '\n'),
+                runProcess,
             });
         }
         const next = [];
@@ -159,7 +195,7 @@ export const init = defineCommand({
             next.push('  pnpm dev');
         }
         next.push('');
-        next.push('Edit the project spec and run `ph-clint regen` to regenerate.');
+        next.push('Edit the project spec and run `ph-clint clint-project-regen` to regenerate.');
         return {
             text: next.join('\n'),
             data: { targetDir, spec, fileCount: result.files.length },

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

@@ -8,6 +8,7 @@ export declare const clintProjectPublish: import("@powerhousedao/ph-clint").Comm
     dir: z.ZodOptional<z.ZodString>;
     dryRun: z.ZodDefault<z.ZodBoolean>;
     skipBuild: z.ZodDefault<z.ZodBoolean>;
+    skipGitCheck: z.ZodDefault<z.ZodBoolean>;
     verbose: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>, {
     text: string;

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

@@ -7,6 +7,7 @@ const inputSchema = z.object({
     dir: z.string().optional().describe('Project root directory'),
     dryRun: z.boolean().default(false).describe('Preview without publishing'),
     skipBuild: z.boolean().default(false),
+    skipGitCheck: z.boolean().default(false).describe('Skip git working tree check'),
     verbose: z.boolean().default(false),
 });
 function formatPlanPreview(plan) {
@@ -34,11 +35,12 @@ export const clintProjectPublish = defineCommand({
             logLines.push(msg);
             stdout(msg + '\n');
         };
-        // 1. Resolve plan
+        // 1. Resolve plan — discover config from the target dir, not process.cwd().
+        const configFile = path.join(dir, 'publish.config.ts');
         const plan = await resolvePublishPlan({
             tag: input.tag,
-            configPath: undefined, // auto-discover from dir
-            skipGitCheck: input.dryRun,
+            configPath: configFile,
+            skipGitCheck: input.dryRun || input.skipGitCheck,
             log,
         });
         // 2. Show preview

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

@@ -1,5 +1,5 @@
 /**
- * `ph-clint regen` — reconcile an existing project against its persisted
+ * `ph-clint clint-project-regen` — reconcile an existing project against its persisted
  * spec. Equivalent to running the generator in update mode.
  *
  * Run inside a project directory (or pass `--dir`). If the spec has flipped
@@ -31,7 +31,7 @@ export const regen = defineCommand({
         if (!spec) {
             return {
                 text: `Error: no spec found at ${targetDir}/.ph/ph-clint-cli/project-spec.json.\n` +
-                    'Run `ph-clint init` first to scaffold a new project.',
+                    'Run `ph-clint clint-project-init` first to scaffold a new project.',
             };
         }
         const warnings = [];

package/dist/commands/clint-skills-sync.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const skillsSync: import("@powerhousedao/ph-clint").Command<z.ZodObject<{
+    dir: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    text: string;
+    data?: undefined;
+} | {
+    text: string;
+    data: import("../skills/sync.js").SyncResult;
+}, Record<string, unknown>>;

package/dist/commands/clint-skills-sync.js

@@ -0,0 +1,56 @@
+/**
+ * `ph-clint clint-skills-sync` — reconcile external skills on disk to match
+ * the project spec.  Clones missing skills from GitHub, removes skills no
+ * longer referenced, and updates `.skills-manifest.json`.
+ */
+import path from 'node:path';
+import { defineCommand } from '@powerhousedao/ph-clint';
+import { z } from 'zod';
+import { readProjectSpec } from '../spec/file.js';
+import { syncExternalSkills } from '../skills/sync.js';
+const inputSchema = z.object({
+    dir: z
+        .string()
+        .optional()
+        .describe('Project directory (defaults to the current directory)'),
+});
+export const skillsSync = defineCommand({
+    id: 'clint-skills-sync',
+    description: 'Synchronise external skills from the project spec',
+    inputSchema,
+    execute: async (input, { workdir, stdout, log }) => {
+        const targetDir = path.resolve(workdir, input.dir ?? '.');
+        const spec = await readProjectSpec(targetDir);
+        if (!spec) {
+            return {
+                text: `Error: no spec found at ${targetDir}/.ph/ph-clint-cli/project-spec.json.\n` +
+                    'Run `ph-clint clint-project-init` first to scaffold a new project.',
+            };
+        }
+        const result = await syncExternalSkills({
+            targetDir,
+            desired: spec.externalSkills,
+            log: (msg) => {
+                if (log)
+                    log.info(msg);
+                else
+                    stdout(msg + '\n');
+            },
+        });
+        const lines = [];
+        if (result.added.length > 0) {
+            lines.push(`Added: ${result.added.join(', ')}`);
+        }
+        if (result.removed.length > 0) {
+            lines.push(`Removed: ${result.removed.join(', ')}`);
+        }
+        if (result.added.length === 0 && result.removed.length === 0) {
+            lines.push('External skills are up to date.');
+        }
+        stdout(lines.join('\n') + '\n');
+        return {
+            text: lines.join('\n'),
+            data: result,
+        };
+    },
+});

package/dist/config.d.ts

@@ -1,5 +1,3 @@
-/** CLI name — used for config resolution, env var prefixing, and .ph/ paths. */
-export declare const CLI_NAME = "ph-clint";
-export declare const CLI_VERSION = "0.0.0";
-/** Project root — resolved from this file's location. */
-export declare const PROJECT_ROOT: string;
+export declare const CLI_ROOT: string;
+export declare const CLI_NAME: string;
+export declare const CLI_VERSION: string;

package/dist/config.js

@@ -1,7 +1,5 @@
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-/** CLI name — used for config resolution, env var prefixing, and .ph/ paths. */
-export const CLI_NAME = 'ph-clint';
-export const CLI_VERSION = '0.0.0';
-/** Project root — resolved from this file's location. */
-export const PROJECT_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+import { readPackageInfo } from '@powerhousedao/ph-clint';
+const pkg = readPackageInfo(import.meta.url);
+export const CLI_ROOT = pkg.root;
+export const CLI_NAME = pkg.name.replace(/-cli$/, '');
+export const CLI_VERSION = pkg.version;