@powerhousedao/ph-clint-cli 0.1.0-dev.14 → 0.1.0-dev.16

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.14",
+  "version": "0.1.0-dev.16",
   "publishConfig": {
     "access": "public"
   },
@@ -25,8 +25,8 @@
     "mastra:start": "mastra start"
   },
   "dependencies": {
-    "@powerhousedao/ph-clint": "^0.1.0-dev.14",
-    "@powerhousedao/ph-clint-app": "^0.1.0-dev.14",
+    "@powerhousedao/ph-clint": "^0.1.0-dev.15",
+    "@powerhousedao/ph-clint-app": "^0.1.0-dev.16",
     "@mastra/core": "^1.22.0",
     "@mastra/libsql": "^1.7.4",
     "@mastra/memory": "^1.13.1",
@@ -37,7 +37,7 @@
     "document-model": "6.0.0-dev.170",
     "kysely": "^0.27.0",
     "kysely-pglite-dialect": "^1.3.0",
-    "@powerhousedao/ph-clint-dev": "^0.1.0-dev.14",
+    "@powerhousedao/ph-clint-dev": "^0.1.0-dev.15",
     "zod": "^4.3.6"
   },
   "pnpm": {