@powerhousedao/ph-clint-cli 0.1.0-dev.0

package/dist/codegen/write.d.ts

@@ -0,0 +1,6 @@
+export declare function writeFileEnsuringDir(filePath: string, content: string): Promise<void>;
+/**
+ * Returns true if the directory doesn't exist or only contains ignorable
+ * entries (`.git`, `.DS_Store`, `.ph/ph-clint-cli/project-spec.json`).
+ */
+export declare function isDirEmptyEnough(dir: string): Promise<boolean>;

package/dist/codegen/write.js

@@ -0,0 +1,32 @@
+/**
+ * Low-level file-writing helpers for the code generator.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export async function writeFileEnsuringDir(filePath, content) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, content, 'utf8');
+}
+function isEnoent(err) {
+    return (!!err &&
+        typeof err === 'object' &&
+        'code' in err &&
+        err.code === 'ENOENT');
+}
+/**
+ * Returns true if the directory doesn't exist or only contains ignorable
+ * entries (`.git`, `.DS_Store`, `.ph/ph-clint-cli/project-spec.json`).
+ */
+export async function isDirEmptyEnough(dir) {
+    let entries;
+    try {
+        entries = await fs.readdir(dir);
+    }
+    catch (err) {
+        if (isEnoent(err))
+            return true;
+        throw err;
+    }
+    const ignorable = new Set(['.git', '.DS_Store', '.ph']);
+    return entries.every((entry) => ignorable.has(entry));
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { type ClintProjectSpec } from '../spec/types.js';
+declare const inputSchema: z.ZodObject<{
+    dir: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    enablePowerhouse: z.ZodDefault<z.ZodBoolean>;
+    enableMastra: z.ZodDefault<z.ZodBoolean>;
+    enableRoutine: z.ZodDefault<z.ZodBoolean>;
+    force: z.ZodDefault<z.ZodBoolean>;
+    skipPhInit: z.ZodDefault<z.ZodBoolean>;
+    skipInstall: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type InitInput = z.output<typeof inputSchema>;
+export declare function buildSpec(input: InitInput): ClintProjectSpec;
+export declare const init: import("@powerhousedao/ph-clint").Command<z.ZodObject<{
+    dir: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    enablePowerhouse: z.ZodDefault<z.ZodBoolean>;
+    enableMastra: z.ZodDefault<z.ZodBoolean>;
+    enableRoutine: z.ZodDefault<z.ZodBoolean>;
+    force: z.ZodDefault<z.ZodBoolean>;
+    skipPhInit: z.ZodDefault<z.ZodBoolean>;
+    skipInstall: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>, {
+    text: string;
+    data?: undefined;
+} | {
+    text: string;
+    data: {
+        targetDir: string;
+        spec: {
+            name: string;
+            version: string;
+            description: string;
+            features: {
+                powerhouse: {
+                    enabled: boolean;
+                    switchboard: boolean;
+                    connect: boolean;
+                };
+                mastra: {
+                    enabled: boolean;
+                };
+                routine: {
+                    enabled: boolean;
+                };
+            };
+            documentTypes: string[];
+            scope?: string | undefined;
+            bin?: string | undefined;
+        };
+        fileCount: number;
+    };
+}, Record<string, unknown>>;
+export {};

package/dist/commands/init.js

@@ -0,0 +1,168 @@
+/**
+ * `ph-clint init` — the project bootstrap wizard.
+ *
+ * Behavior:
+ *   1. Resolve target dir (positional `dir`, defaults to cwd).
+ *   2. Assert it is empty (or `--force`).
+ *   3. Collect project identity + feature toggles (prompt for missing).
+ *   4. Assemble a ClintProjectSpec and validate with Zod.
+ *   5. Write the spec + emit the generated tree via `generateProject`.
+ *   6. (Split layout) run `ph init` in `{name}-app/` unless `--skip-ph-init`.
+ *   7. Run `pnpm install` in generated sub-projects unless `--skip-install`.
+ *   8. Print next-steps guidance.
+ */
+import path from 'node:path';
+import { defineCommand } from '@powerhousedao/ph-clint';
+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';
+const inputSchema = z.object({
+    dir: z
+        .string()
+        .optional()
+        .describe('Target directory (defaults to the current directory)'),
+    name: z
+        .string()
+        .describe('Project name — bare, or `@scope/name`. Lowercase letters, digits, hyphens.'),
+    description: z.string().optional().describe('Short project description'),
+    enablePowerhouse: z
+        .boolean()
+        .default(false)
+        .describe('Enable Powerhouse reactor (requires split layout)'),
+    enableMastra: z
+        .boolean()
+        .default(false)
+        .describe('Enable Mastra AI agent stack'),
+    enableRoutine: z
+        .boolean()
+        .default(false)
+        .describe('Enable the tick-based routine loop'),
+    force: z
+        .boolean()
+        .default(false)
+        .describe('Overwrite files if the target directory is not empty'),
+    skipPhInit: z
+        .boolean()
+        .default(false)
+        .describe('Do not run `ph init` in the app folder after scaffolding'),
+    skipInstall: z
+        .boolean()
+        .default(false)
+        .describe('Do not run `pnpm install` after scaffolding'),
+});
+/** Parse `@scope/name` into { scope, name }. */
+function splitPackageName(raw) {
+    const match = /^@([a-z0-9][a-z0-9-]*)\/([a-z0-9][a-z0-9-]*)$/.exec(raw);
+    if (match)
+        return { scope: match[1], name: match[2] };
+    if (raw.startsWith('@')) {
+        throw new Error(`invalid package name "${raw}" — expected "@scope/name" with lowercase letters, digits, hyphens`);
+    }
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(raw)) {
+        throw new Error(`invalid project name "${raw}" — expected lowercase letters, digits, hyphens`);
+    }
+    return { name: raw };
+}
+export function buildSpec(input) {
+    const { scope, name } = splitPackageName(input.name);
+    // 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 candidate = {
+        name,
+        scope,
+        description: input.description ?? '',
+        features: {
+            powerhouse: { enabled: input.enablePowerhouse },
+            mastra: { enabled: input.enableMastra },
+            routine: { enabled: routine },
+        },
+    };
+    return clintProjectSpecSchema.parse(candidate);
+}
+export const init = defineCommand({
+    id: 'init',
+    description: 'Initialize a new ph-clint project in the target directory',
+    inputSchema,
+    prompt: {
+        promptForDefaults: true,
+        promptOptional: ['description'],
+    },
+    execute: async (input, { workdir, stdout }) => {
+        const targetDir = path.resolve(workdir, input.dir ?? '.');
+        if (!input.force) {
+            const empty = await isDirEmptyEnough(targetDir);
+            if (!empty) {
+                return {
+                    text: `Error: ${targetDir} is not empty. Re-run with --force to initialize anyway,\n` +
+                        'or choose a different --dir.',
+                };
+            }
+        }
+        const spec = buildSpec(input);
+        const result = await generateProject({
+            targetDir,
+            spec,
+            mode: 'create',
+            allowNonEmpty: input.force,
+        });
+        stdout(`Generated ${result.files.length} files in ${targetDir}\n`);
+        const split = spec.features.powerhouse.enabled;
+        // Reactor package scaffolding (split layout only).
+        if (split && result.appDir && !input.skipPhInit) {
+            const phResult = await runPhInit({
+                targetDir,
+                appDir: result.appDir,
+                spec,
+                log: (msg) => stdout(msg + '\n'),
+            });
+            if (!phResult.ran) {
+                stdout(`Note: \`ph init\` did not run — ${phResult.reason ?? 'see above'}.\n`);
+            }
+        }
+        // Dependency installation.
+        if (!input.skipInstall) {
+            const dirs = [];
+            if (split) {
+                if (result.appDir)
+                    dirs.push(result.appDir);
+                dirs.push(result.cliDir);
+            }
+            else {
+                dirs.push(targetDir);
+            }
+            await runPnpmInstall({
+                dirs,
+                log: (msg) => stdout(msg + '\n'),
+            });
+        }
+        const next = [];
+        next.push('');
+        next.push('Next steps:');
+        const relDir = path.relative(workdir, targetDir) || '.';
+        if (split) {
+            next.push(`  cd ${relDir}`);
+            if (input.skipPhInit) {
+                next.push(`  cd ${spec.name}-app && ph init . && cd ..`);
+            }
+            if (input.skipInstall) {
+                next.push('  pnpm install');
+            }
+            next.push('  pnpm dev');
+        }
+        else {
+            next.push(`  cd ${relDir}`);
+            if (input.skipInstall)
+                next.push('  pnpm install');
+            next.push('  pnpm dev');
+        }
+        next.push('');
+        next.push('Edit the project spec and run `ph-clint regen` to regenerate.');
+        return {
+            text: next.join('\n'),
+            data: { targetDir, spec, fileCount: result.files.length },
+        };
+    },
+});

package/dist/commands/regen.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export declare const regen: import("@powerhousedao/ph-clint").Command<z.ZodObject<{
+    dir: z.ZodOptional<z.ZodString>;
+    force: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>, {
+    text: string;
+    data?: undefined;
+} | {
+    text: string;
+    data: {
+        mode: "create" | "update";
+        files: string[];
+        skipped: string[];
+        deleted: string[];
+        migrated: boolean;
+        warnings: string[];
+    };
+}, Record<string, unknown>>;

package/dist/commands/regen.js

@@ -0,0 +1,68 @@
+/**
+ * `ph-clint 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
+ * `features.powerhouse.enabled` since the last run, the flat → split
+ * migration fires first.
+ */
+import path from 'node:path';
+import { defineCommand } from '@powerhousedao/ph-clint';
+import { z } from 'zod';
+import { readProjectSpec } from '../spec/file.js';
+import { generateProject } from '../codegen/index.js';
+const inputSchema = z.object({
+    dir: z
+        .string()
+        .optional()
+        .describe('Project directory (defaults to the current directory)'),
+    force: z
+        .boolean()
+        .default(false)
+        .describe('Overwrite user-edited managed files and bypass the git-dirty guard'),
+});
+export const regen = defineCommand({
+    id: 'regen',
+    description: 'Regenerate project files from the persisted 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 init` first to scaffold a new project.',
+            };
+        }
+        const warnings = [];
+        const result = await generateProject({
+            targetDir,
+            spec,
+            mode: 'update',
+            force: input.force,
+            onWarn: (m) => warnings.push(m),
+        });
+        const lines = [];
+        if (result.migrated)
+            lines.push('Migrated layout: flat → split.');
+        lines.push(`Wrote ${result.files.length} file(s); skipped ${result.skipped.length}; deleted ${result.deleted.length}.`);
+        for (const w of warnings) {
+            if (log)
+                log.warn(w);
+            else
+                stdout('warning: ' + w + '\n');
+        }
+        stdout(lines.join('\n') + '\n');
+        return {
+            text: lines.join('\n'),
+            data: {
+                mode: result.mode,
+                files: result.files.map((f) => f.relativePath),
+                skipped: result.skipped.map((f) => f.relativePath),
+                deleted: result.deleted.map((f) => f.relativePath),
+                migrated: result.migrated,
+                warnings,
+            },
+        };
+    },
+});

package/dist/config.d.ts

@@ -0,0 +1,5 @@
+/** 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;

package/dist/config.js

@@ -0,0 +1,7 @@
+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)), '..');

package/dist/framework.d.ts

@@ -0,0 +1,239 @@
+/**
+ * Per-CLI typed framework binding.
+ *
+ * This file is USER-OWNED. ph-clint-cli emits it once at project creation
+ * and never overwrites it afterwards — edit `configSchema` and
+ * `secretsSchema` freely.
+ *
+ * Typed factories (`defineCommand`, `defineTrigger`, ...) and the document
+ * `registry` come from `framework.gen.ts`, which IS regenerated whenever
+ * the spec's `documentTypes` list changes.
+ */
+import { z } from 'zod';
+export declare const configSchema: z.ZodObject<{
+    model: z.ZodDefault<z.ZodString>;
+    devServicePort: z.ZodDefault<z.ZodNumber>;
+    phVersion: z.ZodDefault<z.ZodString>;
+    projectDocumentId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const secretsSchema: z.ZodObject<{
+    apiKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type Config = z.infer<typeof configSchema> & z.infer<typeof secretsSchema>;
+export declare const defineCommand: <TInput extends z.ZodType, TOutput = unknown>(options: {
+    id: string;
+    description: string;
+    inputSchema: TInput;
+    outputSchema?: z.ZodType<TOutput, unknown, z.core.$ZodTypeInternals<TOutput, unknown>> | undefined;
+    prompt?: import("@powerhousedao/ph-clint").PromptConfig;
+    execute: (input: z.core.output<TInput>, ctx: import("@powerhousedao/ph-clint").CommandContext<{
+        model: string;
+        devServicePort: number;
+        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;
+    }]>>) => Promise<TOutput>;
+}) => import("@powerhousedao/ph-clint").Command<TInput, TOutput, {
+    model: string;
+    devServicePort: number;
+    phVersion: string;
+    projectDocumentId?: string | undefined;
+    apiKey?: string | undefined;
+}>, defineTrigger: <TState = Record<string, unknown>>(options: import("@powerhousedao/ph-clint").TriggerOptions<TState, {
+    model: string;
+    devServicePort: number;
+    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_1 extends import("document-model").PHBaseState = import("document-model").PHBaseState>(state: TState_1 & {
+            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").Trigger<TState, {
+    model: string;
+    devServicePort: number;
+    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_1 extends import("document-model").PHBaseState = import("document-model").PHBaseState>(state: TState_1 & {
+            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;
+}]>>, defineService: (options: import("@powerhousedao/ph-clint").ServiceDefinition<{
+    model: string;
+    devServicePort: number;
+    phVersion: string;
+    projectDocumentId?: string | undefined;
+    apiKey?: string | undefined;
+}>) => import("@powerhousedao/ph-clint").ServiceDefinition<{
+    model: string;
+    devServicePort: number;
+    phVersion: string;
+    projectDocumentId?: string | undefined;
+    apiKey?: string | undefined;
+}>, createDocumentChangeTrigger: <T extends string, TState extends {
+    pending: number;
+} = {
+    pending: number;
+}>(options: import("@powerhousedao/ph-clint").DocumentChangeTriggerOptions<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_1 extends import("document-model").PHBaseState = import("document-model").PHBaseState>(state: TState_1 & {
+            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;
+}]>, T, {
+    model: string;
+    devServicePort: number;
+    phVersion: string;
+    projectDocumentId?: string | undefined;
+    apiKey?: string | undefined;
+}, TState>) => import("@powerhousedao/ph-clint").Trigger<TState, {
+    model: string;
+    devServicePort: number;
+    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_1 extends import("document-model").PHBaseState = import("document-model").PHBaseState>(state: TState_1 & {
+            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;
+}]>>;
+export { registry } from './framework.gen.js';
+export type { Registry } from './framework.gen.js';

package/dist/framework.gen.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Typed document registry derived from the reactor package's document models.
+ * Regenerated whenever the spec's `documentTypes` list changes.
+ */
+export declare const registry: 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;
+}]>;
+export type Registry = typeof registry;