@powerhousedao/ph-clint-cli 0.1.0-dev.15 → 0.1.0-dev.17

package/dist/spec/types.js

@@ -9,29 +9,41 @@
  * generator step actually needs it.
  */
 import { z } from 'zod';
-const powerhouseFeatureSchema = z.object({
-    enabled: z.boolean().default(false),
-    switchboard: z.boolean().default(true),
-    connect: z.boolean().default(true),
-});
+/**
+ * Ordered Powerhouse integration level. Higher levels imply all lower ones:
+ *   Disabled → Reactor → Switchboard → Connect
+ */
+export const POWERHOUSE_LEVELS = [
+    'Disabled',
+    'Reactor',
+    'Switchboard',
+    'Connect',
+];
+export const powerhouseLevelSchema = z
+    .enum(POWERHOUSE_LEVELS)
+    .default('Disabled');
+/** Check whether `level` is at least `threshold` in the ordered enum. */
+export function phAtLeast(level, threshold) {
+    return (POWERHOUSE_LEVELS.indexOf(level) >= POWERHOUSE_LEVELS.indexOf(threshold));
+}
 const mastraFeatureSchema = z.object({
     enabled: z.boolean().default(false),
 });
 const routineFeatureSchema = z.object({
     enabled: z.boolean().default(false),
 });
-// Zod 4 does not cascade `.default({})` through nested object schemas — a
-// missing outer key fills in `{}`, but nested keys with their own `.default`
-// are not re-defaulted unless the object itself re-parses. We spell out full
-// defaults here so `clintProjectSpecSchema.parse({ name: 'x' })` yields a
-// fully-populated feature tree.
-const DEFAULT_POWERHOUSE = {
-    enabled: false,
-    switchboard: true,
-    connect: true,
-};
 const DEFAULT_MASTRA = { enabled: false };
 const DEFAULT_ROUTINE = { enabled: false };
+export const powerhousePackageSchema = z.object({
+    id: z.string(),
+    packageName: z.string(),
+    documentTypes: z.array(z.string()).default([]),
+});
+export const externalSkillSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    githubUrl: z.string(),
+});
 export const clintProjectSpecSchema = z.object({
     name: z
         .string()
@@ -45,24 +57,28 @@ export const clintProjectSpecSchema = z.object({
     bin: z.string().optional(),
     features: z
         .object({
-        powerhouse: powerhouseFeatureSchema.default(DEFAULT_POWERHOUSE),
+        powerhouse: powerhouseLevelSchema,
         mastra: mastraFeatureSchema.default(DEFAULT_MASTRA),
         routine: routineFeatureSchema.default(DEFAULT_ROUTINE),
     })
         .default({
-        powerhouse: DEFAULT_POWERHOUSE,
+        powerhouse: 'Disabled',
         mastra: DEFAULT_MASTRA,
         routine: DEFAULT_ROUTINE,
     }),
     /**
-     * Document types registered with this CLI — full documentType ID strings
-     * (e.g. `powerhouse/ph-clint-project`). Drives codegen of `src/framework.gen.ts`,
-     * which emits a typed `defineRegistry([...] as const)` call so impl code
-     * gets narrowed `reactor.client.get(id, 'my-type')` access. Empty on
-     * fresh projects — populated as document models are added to the reactor
-     * package.
+     * Reactor packages and their document types. Each entry groups a package
+     * name with the document type IDs it provides. The app package (project's
+     * own reactor package) uses a `file:` dependency; external packages become
+     * versioned npm dependencies. Drives codegen of `framework.gen.ts`,
+     * `app/index.ts`, and `cli/package.json`.
      */
-    documentTypes: z.array(z.string()).default([]),
+    packages: z.array(powerhousePackageSchema).default([]),
+    /**
+     * External skills from the skills.sh ecosystem. Each skill has a name
+     * (kebab-case) and a GitHub URL for installation.
+     */
+    externalSkills: z.array(externalSkillSchema).default([]),
 });
 /** npm package name (e.g. `@scope/foo` or `foo`). */
 export function getPackageName(spec) {
@@ -85,6 +101,26 @@ export function getCliFolderName(spec) {
 export function getAppFolderName(spec) {
     return `${spec.name}-app`;
 }
+/**
+ * Flat list of all document types across all packages. Convenience for
+ * codegen that needs to iterate every registered document type regardless
+ * of which package provides it.
+ */
+export function getAllDocumentTypes(spec) {
+    return spec.packages.flatMap((p) => p.documentTypes);
+}
+/**
+ * The app npm package name (`@scope/{name}-app` or `{name}-app`).
+ * Matches what the document model reducer stores in `packages[].packageName`.
+ */
+export function getAppPackageName(spec) {
+    const base = `${spec.name}-app`;
+    return spec.scope ? `@${spec.scope}/${base}` : base;
+}
+/** Directory name for the app package (`{name}-app`, no scope prefix). */
+export function getAppDirName(spec) {
+    return `${spec.name}-app`;
+}
 /**
  * Folder slug for a documentType ID. The slug is the portion after the last
  * `/` (e.g. `powerhouse/ph-clint-project` → `ph-clint-project`). Matches the

package/dist/triggers/publish-trigger.d.ts

@@ -0,0 +1,11 @@
+/** Map document model PublishTag values to CLI --tag values. */
+export declare function tagToCli(tag: string): 'dev' | 'staging' | 'production' | null;
+export declare const publishTrigger: import("@powerhousedao/ph-clint").Trigger<{
+    pending: number;
+}, {
+    model: string;
+    devServicePort: number;
+    phVersion: string;
+    projectDocumentId?: string | undefined;
+    apiKey?: string | undefined;
+}, import("@powerhousedao/ph-clint").InferRegistry<readonly [import("document-model").DocumentModelModule<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>]>>;

package/dist/triggers/publish-trigger.js

@@ -0,0 +1,172 @@
+/**
+ * `publish-trigger` — watches `powerhouse/ph-clint-project` documents for
+ * publish records with `Pending` status and invokes the publish pipeline.
+ *
+ * Unlike `spec-change`, this trigger does NOT convert to a `ClintProjectSpec`.
+ * It reads `publishHistory` directly from the document state, since publish
+ * records are a doc-model concern (not a codegen input).
+ *
+ * Flow:
+ *   1. On document change, scans `publishHistory` for records with status
+ *      `"Pending"`.
+ *   2. For each pending record, returns a work item that:
+ *      a. Dispatches SET_PUBLISH_STATUS({ id, status: "InProgress" }).
+ *      b. Runs `ph-clint clint-project-publish --tag <tag>`.
+ *      c. Dispatches SET_PUBLISH_STATUS({ id, status: "Succeeded"|"Failed" }).
+ */
+import { spawn } from 'node:child_process';
+import { setPublishStatus } from '@powerhousedao/ph-clint-app';
+import { createDocumentChangeTrigger } from '../framework.js';
+const DOCUMENT_TYPE = 'powerhouse/ph-clint-project';
+const TAG = '[publish]';
+/** Find the first ph-clint-project document on the default drive. */
+async function findProjectDocumentId(client, driveId) {
+    try {
+        const children = await client.getChildren(driveId);
+        const results = (children?.results ?? []);
+        for (const node of results) {
+            if (node.header?.documentType === DOCUMENT_TYPE && node.header.id) {
+                return node.header.id;
+            }
+        }
+    }
+    catch {
+        // fall through
+    }
+    return undefined;
+}
+/** Run a shell command and return stdout. Rejects on non-zero exit. */
+function exec(cmd, args, cwd, onLog) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn(cmd, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+        const out = [];
+        const err = [];
+        proc.stdout?.on('data', (d) => {
+            const s = d.toString();
+            out.push(s);
+            if (onLog)
+                for (const line of s.split('\n'))
+                    if (line.trim())
+                        onLog(line.trim());
+        });
+        proc.stderr?.on('data', (d) => {
+            const s = d.toString();
+            err.push(s);
+            if (onLog)
+                for (const line of s.split('\n'))
+                    if (line.trim())
+                        onLog(line.trim());
+        });
+        proc.on('error', reject);
+        proc.on('close', (code) => {
+            if (code === 0)
+                resolve(out.join(''));
+            else
+                reject(new Error(`${cmd} ${args.join(' ')} exited ${code}\n${err.join('')}`));
+        });
+    });
+}
+/** Map document model PublishTag values to CLI --tag values. */
+export function tagToCli(tag) {
+    switch (tag) {
+        case 'Dev':
+            return 'dev';
+        case 'Staging':
+            return 'staging';
+        case 'Production':
+            return 'production';
+        default:
+            return null;
+    }
+}
+export const publishTrigger = createDocumentChangeTrigger({
+    id: 'publish-trigger',
+    documentType: DOCUMENT_TYPE,
+    // Don't fire on startup — only react to new pending records.
+    initialReconcile: false,
+    // Resolve the target document lazily (same pattern as spec-change trigger).
+    documentId: async (ctx) => {
+        const configured = ctx.context.config.projectDocumentId &&
+            ctx.context.config.projectDocumentId.length > 0
+            ? ctx.context.config.projectDocumentId
+            : undefined;
+        if (configured)
+            return configured;
+        const reactor = await ctx.reactor();
+        if (!reactor)
+            return undefined;
+        return findProjectDocumentId(reactor.client, reactor.driveId);
+    },
+    async onChange(doc, ctx) {
+        const log = ctx.context.log;
+        const publishHistory = doc.state.global.publishHistory ?? [];
+        const pending = publishHistory.filter((r) => r.status === 'Pending');
+        if (pending.length === 0)
+            return null;
+        // Process the first pending record (one per tick to avoid races).
+        const record = pending[0];
+        const cliTag = tagToCli(record.tag);
+        if (!cliTag) {
+            log?.warn(`${TAG} unknown publish tag "${record.tag}" for record ${record.id}`);
+            return null;
+        }
+        log?.info(`${TAG} found pending ${record.tag} publish (id=${record.id}, version=${record.version})`);
+        return {
+            type: 'function',
+            params: {
+                fn: async () => {
+                    const reactor = await ctx.reactor();
+                    if (!reactor) {
+                        log?.error(`${TAG} reactor not available, cannot update publish status`);
+                        return;
+                    }
+                    // Mark as InProgress.
+                    log?.info(`${TAG} marking record ${record.id} as InProgress`);
+                    await reactor.client.execute(doc.header.id, 'main', [
+                        setPublishStatus({ id: record.id, status: 'InProgress' }),
+                    ]);
+                    // Install dependencies in the generated project before publishing.
+                    const workdir = ctx.context.workdir;
+                    log?.info(`${TAG} running pnpm install in ${workdir}`);
+                    try {
+                        await exec('pnpm', ['install'], workdir, (msg) => log?.debug(`${TAG} [install] ${msg}`));
+                    }
+                    catch (installErr) {
+                        log?.error(`${TAG} pnpm install failed: ${installErr instanceof Error ? installErr.message : String(installErr)}`);
+                    }
+                    // Run the publish command.
+                    let success = false;
+                    try {
+                        log?.info(`${TAG} invoking clint-project-publish --tag ${cliTag}`);
+                        const { clintProjectPublish } = await import('../commands/clint-project-publish.js');
+                        const result = await clintProjectPublish.execute({ tag: cliTag, dryRun: false, skipBuild: false, skipGitCheck: true, verbose: false }, 
+                        // @ts-expect-error — minimal context; publish uses workdir + stdout.
+                        {
+                            workdir: ctx.context.workdir,
+                            stdout: (msg) => log?.info(`${TAG} ${msg}`),
+                            log,
+                        });
+                        success = !result.text.includes('failed');
+                    }
+                    catch (err) {
+                        log?.error(`${TAG} publish failed: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                    // Update status.
+                    const finalStatus = success ? 'Succeeded' : 'Failed';
+                    log?.info(`${TAG} marking record ${record.id} as ${finalStatus}`);
+                    await reactor.client.execute(doc.header.id, 'main', [
+                        setPublishStatus({
+                            id: record.id,
+                            status: finalStatus,
+                        }),
+                    ]);
+                },
+            },
+            callbacks: {
+                onFailure: (err) => {
+                    log?.error(`${TAG} publish trigger failed: ${err.message}`);
+                },
+            },
+        };
+    },
+});

package/dist/triggers/spec-change.d.ts

@@ -9,35 +9,4 @@ export declare const specChangeTrigger: import("@powerhousedao/ph-clint").Trigge
     phVersion: string;
     projectDocumentId?: string | undefined;
     apiKey?: string | undefined;
-}, import("@powerhousedao/ph-clint").InferRegistry<readonly [{
-    readonly version: 1;
-    readonly reducer: import("document-model").Reducer<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>;
-    readonly actions: {
-        enableRoutine: (input: import("@powerhousedao/ph-clint-app").EnableRoutineInput) => import("@powerhousedao/ph-clint-app").EnableRoutineAction;
-        disableRoutine: (input: import("@powerhousedao/ph-clint-app").DisableRoutineInput) => import("@powerhousedao/ph-clint-app").DisableRoutineAction;
-        enableMastra: (input: import("@powerhousedao/ph-clint-app").EnableMastraInput) => import("@powerhousedao/ph-clint-app").EnableMastraAction;
-        disableMastra: (input: import("@powerhousedao/ph-clint-app").DisableMastraInput) => import("@powerhousedao/ph-clint-app").DisableMastraAction;
-        enablePowerhouse: (input: import("@powerhousedao/ph-clint-app").EnablePowerhouseInput) => import("@powerhousedao/ph-clint-app").EnablePowerhouseAction;
-        setPowerhouseSwitchboard: (input: import("@powerhousedao/ph-clint-app").SetPowerhouseSwitchboardInput) => import("@powerhousedao/ph-clint-app").SetPowerhouseSwitchboardAction;
-        setPowerhouseConnect: (input: import("@powerhousedao/ph-clint-app").SetPowerhouseConnectInput) => import("@powerhousedao/ph-clint-app").SetPowerhouseConnectAction;
-        setPackageName: (input: import("@powerhousedao/ph-clint-app").SetPackageNameInput) => import("@powerhousedao/ph-clint-app").SetPackageNameAction;
-        clearBin: (input: import("@powerhousedao/ph-clint-app").ClearBinInput) => import("@powerhousedao/ph-clint-app").ClearBinAction;
-        setBin: (input: import("@powerhousedao/ph-clint-app").SetBinInput) => import("@powerhousedao/ph-clint-app").SetBinAction;
-        setDescription: (input: import("@powerhousedao/ph-clint-app").SetDescriptionInput) => import("@powerhousedao/ph-clint-app").SetDescriptionAction;
-        setVersion: (input: import("@powerhousedao/ph-clint-app").SetVersionInput) => import("@powerhousedao/ph-clint-app").SetVersionAction;
-        clearScope: (input: import("@powerhousedao/ph-clint-app").ClearScopeInput) => import("@powerhousedao/ph-clint-app").ClearScopeAction;
-        setScope: (input: import("@powerhousedao/ph-clint-app").SetScopeInput) => import("@powerhousedao/ph-clint-app").SetScopeAction;
-        setName: (name: string | {
-            name: string;
-        }) => import("document-model").SetNameAction;
-        undo: (count?: number, scope?: string) => import("document-model").UndoAction;
-        redo: (count?: number, scope?: string) => import("document-model").RedoAction;
-        prune: (start?: number, end?: number, scope?: string) => import("document-model").SchemaPruneAction;
-        loadState: <TState extends import("document-model").PHBaseState = import("document-model").PHBaseState>(state: TState & {
-            name: string;
-        }, operations: number) => import("document-model").LoadStateAction;
-        noop: (scope?: string) => import("document-model").NOOPAction;
-    };
-    readonly utils: import("document-model").DocumentModelUtils<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>;
-    readonly documentModel: import("document-model").DocumentModelPHState;
-}]>>;
+}, import("@powerhousedao/ph-clint").InferRegistry<readonly [import("document-model").DocumentModelModule<import("@powerhousedao/ph-clint-app").PhClintProjectPHState>]>>;

package/dist/triggers/spec-change.js

@@ -20,7 +20,9 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { createDocumentChangeTrigger } from '../framework.js';
 import { generateProject } from '../codegen/index.js';
+import { runPhInit } from '../codegen/scaffold.js';
 import { specFromDocumentState } from '../spec/from-document.js';
+import { syncExternalSkills } from '../skills/sync.js';
 const DOCUMENT_TYPE = 'powerhouse/ph-clint-project';
 const HASH_DIR = path.join('.ph', 'ph-clint-cli');
 const HASH_FILE = '.last-spec-hash';
@@ -147,6 +149,7 @@ export const specChangeTrigger = createDocumentChangeTrigger({
                         targetDir,
                         spec,
                         mode: 'update',
+                        force: true,
                         onWarn: (m) => warnings.push(m),
                     });
                     await writeLastSpecHash(targetDir, nextHash);
@@ -158,6 +161,43 @@ 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}`),
+                                stdio: 'ignore',
+                            });
+                            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}`);
+                            }
+                        }
+                    }
+                    // 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}`);
+                        }
+                    }
                 },
             },
             callbacks: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powerhousedao/ph-clint-cli",
-  "version": "0.1.0-dev.15",
+  "version": "0.1.0-dev.17",
   "publishConfig": {
     "access": "public"
   },
@@ -26,7 +26,7 @@
   },
   "dependencies": {
     "@powerhousedao/ph-clint": "^0.1.0-dev.15",
-    "@powerhousedao/ph-clint-app": "^0.1.0-dev.15",
+    "@powerhousedao/ph-clint-app": "^0.1.0-dev.17",
     "@mastra/core": "^1.22.0",
     "@mastra/libsql": "^1.7.4",
     "@mastra/memory": "^1.13.1",