@powerhousedao/ph-clint-cli 0.1.0-dev.1 → 0.1.0-dev.100

package/dist/cli.js

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

package/dist/codegen/index.d.ts

@@ -1,39 +1,11 @@
-import { type ClintProjectSpec } from '../spec/types.js';
-export type GenerateMode = 'create' | 'update' | 'auto';
-export interface GenerateProjectOptions {
-    /** Absolute path to the project root. */
-    targetDir: string;
-    spec: ClintProjectSpec;
-    /** Defaults to `'auto'` — create if no persisted spec, else update. */
-    mode?: GenerateMode;
-    /** Create mode: allow writing into a non-empty directory. */
-    allowNonEmpty?: boolean;
-    /**
-     * Update mode: overwrite user-edited files (hash-mismatch) anyway.
-     * Also relaxes the git-dirty guard on flat → split migration.
-     */
-    force?: boolean;
-    /** Optional warning sink (diagnostics, not errors). */
-    onWarn?: (msg: string) => void;
-}
-export interface GeneratedFile {
-    absolutePath: string;
-    relativePath: string;
-}
-export interface GenerateProjectResult {
-    mode: 'create' | 'update';
-    /** Files newly written or rewritten. */
-    files: GeneratedFile[];
-    /** Files skipped because the user had edited them. */
-    skipped: GeneratedFile[];
-    /** Files removed because the new spec no longer emits them. */
-    deleted: GeneratedFile[];
-    /** True if a flat → split migration ran. */
-    migrated: boolean;
-    cliDir: string;
-    appDir: string | null;
-}
 /**
- * Generate / reconcile a project at `targetDir` from the given spec.
+ * Re-exports from @powerhousedao/ph-clint-dev/codegen with CLI_VERSION default.
  */
+import { type GenerateProjectOptions as DevGenerateProjectOptions, type GenerateProjectResult, type GenerateMode, type GeneratedFile } from '@powerhousedao/ph-clint-dev/codegen';
+import type { CodegenContext } from '@powerhousedao/ph-clint-dev/codegen/types';
+export type { GenerateProjectResult, GenerateMode, GeneratedFile, CodegenContext };
+export interface GenerateProjectOptions extends Omit<DevGenerateProjectOptions, 'context'> {
+    /** Codegen context; defaults to CLI_VERSION when omitted. */
+    context?: CodegenContext;
+}
 export declare function generateProject(options: GenerateProjectOptions): Promise<GenerateProjectResult>;

package/dist/codegen/index.js

@@ -1,292 +1,11 @@
 /**
- * Code generator entry point.
- *
- * Takes a `ClintProjectSpec` + target directory and reconciles the on-disk
- * project tree with it.
- *
- * Two modes:
- *
- * - **create** — the target dir is empty (or only contains ignorable
- *   artefacts). Every templated file is written fresh. Refuses to
- *   overwrite existing non-empty state unless `allowNonEmpty`.
- *
- * - **update** — a previous run's spec exists at
- *   `.ph/ph-clint-cli/project-spec.json`. Re-runs the builders, then for
- *   each emitted file:
- *     - files containing `@clint:begin/@clint:end` markers (today: just
- *       `src/cli.ts`) have their marker regions spliced in-place, leaving
- *       user code outside markers untouched;
- *     - files without markers are overwritten iff their on-disk hash still
- *       matches the hash stored from the previous write (user-edited files
- *       are skipped and surfaced via `onWarn`);
- *     - files the new spec no longer emits are removed if their hash still
- *       matches.
- *
- * A spec flip of `features.powerhouse.enabled` from `false` to `true`
- * triggers the flat → split migration before the update flow runs.
- *
- * Mode is auto-detected by the presence of the persisted spec.
- */
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { getAppFolderName, getCliFolderName, } from '../spec/types.js';
-import { getSpecPath, readProjectSpec, writeProjectSpec, } from '../spec/file.js';
-import { hashContent, hashFile, readHashes, writeHashes, } from './hashes.js';
-import { hasMarkers, spliceMarkerRegions } from './markers.js';
-import { writeFileEnsuringDir, isDirEmptyEnough } from './write.js';
-import { migrateFlatToSplit } from './migrate/flat-to-split.js';
-import { CLI_FILE_BUILDERS, buildReadme, buildRootPackageJson, buildAppIndexTs, } from './builders/index.js';
-/**
- * Generate / reconcile a project at `targetDir` from the given spec.
+ * Re-exports from @powerhousedao/ph-clint-dev/codegen with CLI_VERSION default.
  */
+import { generateProject as _generateProject, } from '@powerhousedao/ph-clint-dev/codegen';
+import { CLI_VERSION } from '../config.js';
 export async function generateProject(options) {
-    const { targetDir, spec } = options;
-    const warn = options.onWarn ?? (() => { });
-    const existingSpec = await readProjectSpec(targetDir);
-    const resolvedMode = resolveMode(options.mode ?? 'auto', existingSpec !== null);
-    // Flat → split migration, if needed. Runs BEFORE we compute planned files
-    // so the hash record and on-disk state are already in split-layout shape
-    // by the time the normal reconciliation runs.
-    let migrated = false;
-    if (resolvedMode === 'update' &&
-        existingSpec &&
-        !existingSpec.features.powerhouse.enabled &&
-        spec.features.powerhouse.enabled) {
-        await migrateFlatToSplit({
-            targetDir,
-            spec,
-            force: options.force,
-            onWarn: warn,
-        });
-        migrated = true;
-    }
-    // Dispatch to the mode-specific flow.
-    if (resolvedMode === 'create') {
-        return runCreate(options, warn);
-    }
-    return runUpdate(options, warn, migrated);
-}
-function resolveMode(requested, specExists) {
-    if (requested === 'create')
-        return 'create';
-    if (requested === 'update')
-        return 'update';
-    return specExists ? 'update' : 'create';
-}
-/** Build the list of files the new spec would emit, with their content. */
-function planFiles(spec, targetDir) {
-    const split = spec.features.powerhouse.enabled;
-    const cliDir = split ? path.join(targetDir, getCliFolderName(spec)) : targetDir;
-    const appDir = split ? path.join(targetDir, getAppFolderName(spec)) : null;
-    const planned = [];
-    for (const builder of CLI_FILE_BUILDERS) {
-        const content = builder.build(spec);
-        if (content === null)
-            continue;
-        const abs = path.join(cliDir, builder.relativePath);
-        planned.push({
-            relativePath: path.relative(targetDir, abs),
-            absolutePath: abs,
-            content,
-            initOnly: builder.initOnly,
-        });
-    }
-    // Project-root README — always at the top level.
-    const readmeAbs = path.join(targetDir, 'README.md');
-    planned.push({
-        relativePath: 'README.md',
-        absolutePath: readmeAbs,
-        content: buildReadme(spec),
+    return _generateProject({
+        ...options,
+        context: options.context ?? { toolVersion: CLI_VERSION },
     });
-    // Split-layout only: root package.json + app placeholder files.
-    if (split && appDir) {
-        const rootPkg = path.join(targetDir, 'package.json');
-        planned.push({
-            relativePath: 'package.json',
-            absolutePath: rootPkg,
-            content: buildRootPackageJson(spec),
-        });
-        const appGitkeep = path.join(appDir, '.gitkeep');
-        planned.push({
-            relativePath: path.relative(targetDir, appGitkeep),
-            absolutePath: appGitkeep,
-            content: '',
-        });
-        const appReadme = path.join(appDir, 'README.md');
-        planned.push({
-            relativePath: path.relative(targetDir, appReadme),
-            absolutePath: appReadme,
-            content: buildAppReadmeContent(spec),
-        });
-        // Top-level barrel for the reactor package — lets impl code import from
-        // `{name}-app` instead of drilling into `document-models/<slug>/v1/gen`.
-        const appIndex = buildAppIndexTs(spec);
-        if (appIndex !== null) {
-            const appIndexAbs = path.join(appDir, 'index.ts');
-            planned.push({
-                relativePath: path.relative(targetDir, appIndexAbs),
-                absolutePath: appIndexAbs,
-                content: appIndex,
-            });
-        }
-    }
-    return { planned, cliDir, appDir };
-}
-function buildAppReadmeContent(spec) {
-    return [
-        `# ${spec.name}-app`,
-        '',
-        'Powerhouse reactor-package for this project. Scaffold it with:',
-        '',
-        '```sh',
-        `cd ${spec.name}-app`,
-        'ph init',
-        '```',
-        '',
-        'Then run `pnpm install` at the project root.',
-        '',
-    ].join('\n');
-}
-/** Create mode — empty target dir, write everything fresh. */
-async function runCreate(options, _warn) {
-    const { targetDir, spec } = options;
-    if (!options.allowNonEmpty) {
-        const empty = await isDirEmptyEnough(targetDir);
-        if (!empty) {
-            throw new Error(`target directory ${targetDir} is not empty (pass allowNonEmpty or --force to override)`);
-        }
-    }
-    const { planned, cliDir, appDir } = planFiles(spec, targetDir);
-    const hashes = {};
-    const files = [];
-    for (const p of planned) {
-        await writeFileEnsuringDir(p.absolutePath, p.content);
-        hashes[p.relativePath] = hashContent(p.content);
-        files.push({ absolutePath: p.absolutePath, relativePath: p.relativePath });
-    }
-    await writeProjectSpec(targetDir, spec);
-    files.push({
-        absolutePath: getSpecPath(targetDir),
-        relativePath: path.relative(targetDir, getSpecPath(targetDir)),
-    });
-    await writeHashes(targetDir, hashes);
-    return {
-        mode: 'create',
-        files,
-        skipped: [],
-        deleted: [],
-        migrated: false,
-        cliDir,
-        appDir,
-    };
-}
-/** Update mode — reconcile against an existing project. */
-async function runUpdate(options, warn, migrated) {
-    const { targetDir, spec } = options;
-    const force = !!options.force;
-    const { planned, cliDir, appDir } = planFiles(spec, targetDir);
-    const plannedByKey = new Map(planned.map((p) => [p.relativePath, p]));
-    const previous = await readHashes(targetDir);
-    const next = {};
-    const files = [];
-    const skipped = [];
-    const deleted = [];
-    // Step 1: write / patch / skip each planned file.
-    for (const p of planned) {
-        if (p.initOnly) {
-            // User-owned files (e.g. `src/framework.ts` with its `configSchema`)
-            // are emitted only on create. In update mode we never overwrite them
-            // and never re-create them if missing — the user may have deliberately
-            // deleted or inlined them. Keep whatever hash the previous run stored
-            // so the deletion pass (step 2) still considers them "ours".
-            const stored = previous[p.relativePath];
-            if (stored !== undefined)
-                next[p.relativePath] = stored;
-            continue;
-        }
-        const existing = await hashFile(p.absolutePath);
-        if (existing === null) {
-            // Not yet on disk — fresh write.
-            await writeFileEnsuringDir(p.absolutePath, p.content);
-            next[p.relativePath] = hashContent(p.content);
-            files.push({
-                absolutePath: p.absolutePath,
-                relativePath: p.relativePath,
-            });
-            continue;
-        }
-        // File exists. Decide how to update it.
-        if (hasMarkers(p.content)) {
-            const existingContent = await fs.readFile(p.absolutePath, 'utf8');
-            const patched = hasMarkers(existingContent)
-                ? spliceMarkerRegions(existingContent, p.content)
-                : p.content;
-            if (patched === existingContent) {
-                // No-op: regions already match.
-                next[p.relativePath] = hashContent(patched);
-                continue;
-            }
-            await writeFileEnsuringDir(p.absolutePath, patched);
-            next[p.relativePath] = hashContent(patched);
-            files.push({
-                absolutePath: p.absolutePath,
-                relativePath: p.relativePath,
-            });
-            continue;
-        }
-        // No markers — hash-protected overwrite.
-        const stored = previous[p.relativePath];
-        const pristine = stored !== undefined && stored === existing;
-        if (!pristine && !force) {
-            // User edited a managed file. Leave it alone.
-            warn(`skipped ${p.relativePath} — modified since last generation. Use --force to overwrite.`);
-            skipped.push({
-                absolutePath: p.absolutePath,
-                relativePath: p.relativePath,
-            });
-            // Preserve the previous hash so the file stays on our ledger.
-            if (stored !== undefined)
-                next[p.relativePath] = stored;
-            continue;
-        }
-        if (existing === hashContent(p.content)) {
-            // Already up to date.
-            next[p.relativePath] = existing;
-            continue;
-        }
-        await writeFileEnsuringDir(p.absolutePath, p.content);
-        next[p.relativePath] = hashContent(p.content);
-        files.push({
-            absolutePath: p.absolutePath,
-            relativePath: p.relativePath,
-        });
-    }
-    // Step 2: delete files that the new spec no longer emits, IF we still
-    // recognise their content (hash match). Otherwise warn and keep.
-    for (const [relPath, storedHash] of Object.entries(previous)) {
-        if (plannedByKey.has(relPath))
-            continue;
-        const abs = path.join(targetDir, relPath);
-        const onDisk = await hashFile(abs);
-        if (onDisk === null)
-            continue; // already gone
-        if (onDisk !== storedHash && !force) {
-            warn(`kept ${relPath} — modified since last generation; new spec no longer emits it.`);
-            next[relPath] = storedHash;
-            continue;
-        }
-        await fs.rm(abs, { force: true });
-        deleted.push({ absolutePath: abs, relativePath: relPath });
-    }
-    await writeProjectSpec(targetDir, spec);
-    await writeHashes(targetDir, next);
-    return {
-        mode: 'update',
-        files,
-        skipped,
-        deleted,
-        migrated,
-        cliDir,
-        appDir,
-    };
 }

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

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+export declare const build: import("@powerhousedao/ph-clint").Command<z.ZodObject<{
+    dir: z.ZodOptional<z.ZodString>;
+    verbose: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>, {
+    text: string;
+}, {
+    model: string;
+    devServicePort: number;
+    phVersion: string;
+    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: {
+        setAgentModel: (input: import("@powerhousedao/ph-clint-app").SetAgentModelInput) => import("@powerhousedao/ph-clint-app").SetAgentModelAction;
+        addAgentProfileRef: (input: import("@powerhousedao/ph-clint-app").AddAgentProfileRefInput) => import("@powerhousedao/ph-clint-app").AddAgentProfileRefAction;
+        removeAgentProfileRef: (input: import("@powerhousedao/ph-clint-app").RemoveAgentProfileRefInput) => import("@powerhousedao/ph-clint-app").RemoveAgentProfileRefAction;
+        reorderAgentProfileRefs: (input: import("@powerhousedao/ph-clint-app").ReorderAgentProfileRefsInput) => import("@powerhousedao/ph-clint-app").ReorderAgentProfileRefsAction;
+        addAgentSkill: (input: import("@powerhousedao/ph-clint-app").AddAgentSkillInput) => import("@powerhousedao/ph-clint-app").AddAgentSkillAction;
+        removeAgentSkill: (input: import("@powerhousedao/ph-clint-app").RemoveAgentSkillInput) => import("@powerhousedao/ph-clint-app").RemoveAgentSkillAction;
+        addAgentToolPattern: (input: import("@powerhousedao/ph-clint-app").AddAgentToolPatternInput) => import("@powerhousedao/ph-clint-app").AddAgentToolPatternAction;
+        removeAgentToolPattern: (input: import("@powerhousedao/ph-clint-app").RemoveAgentToolPatternInput) => import("@powerhousedao/ph-clint-app").RemoveAgentToolPatternAction;
+        addSubAgent: (input: import("@powerhousedao/ph-clint-app").AddSubAgentInput) => import("@powerhousedao/ph-clint-app").AddSubAgentAction;
+        removeSubAgent: (input: import("@powerhousedao/ph-clint-app").RemoveSubAgentInput) => import("@powerhousedao/ph-clint-app").RemoveSubAgentAction;
+        setSubAgentName: (input: import("@powerhousedao/ph-clint-app").SetSubAgentNameInput) => import("@powerhousedao/ph-clint-app").SetSubAgentNameAction;
+        setSubAgentDescription: (input: import("@powerhousedao/ph-clint-app").SetSubAgentDescriptionInput) => import("@powerhousedao/ph-clint-app").SetSubAgentDescriptionAction;
+        setMainAgentName: (input: import("@powerhousedao/ph-clint-app").SetMainAgentNameInput) => import("@powerhousedao/ph-clint-app").SetMainAgentNameAction;
+        setMainAgentDescription: (input: import("@powerhousedao/ph-clint-app").SetMainAgentDescriptionInput) => import("@powerhousedao/ph-clint-app").SetMainAgentDescriptionAction;
+        clearMainAgentDescription: (input: import("@powerhousedao/ph-clint-app").ClearMainAgentDescriptionInput) => import("@powerhousedao/ph-clint-app").ClearMainAgentDescriptionAction;
+        setMainAgentImage: (input: import("@powerhousedao/ph-clint-app").SetMainAgentImageInput) => import("@powerhousedao/ph-clint-app").SetMainAgentImageAction;
+        clearMainAgentImage: (input: import("@powerhousedao/ph-clint-app").ClearMainAgentImageInput) => import("@powerhousedao/ph-clint-app").ClearMainAgentImageAction;
+        addProfile: (input: import("@powerhousedao/ph-clint-app").AddProfileInput) => import("@powerhousedao/ph-clint-app").AddProfileAction;
+        updateProfile: (input: import("@powerhousedao/ph-clint-app").UpdateProfileInput) => import("@powerhousedao/ph-clint-app").UpdateProfileAction;
+        removeProfile: (input: import("@powerhousedao/ph-clint-app").RemoveProfileInput) => import("@powerhousedao/ph-clint-app").RemoveProfileAction;
+        reorderProfiles: (input: import("@powerhousedao/ph-clint-app").ReorderProfilesInput) => import("@powerhousedao/ph-clint-app").ReorderProfilesAction;
+        addModel: (input: import("@powerhousedao/ph-clint-app").AddModelInput) => import("@powerhousedao/ph-clint-app").AddModelAction;
+        removeModel: (input: import("@powerhousedao/ph-clint-app").RemoveModelInput) => import("@powerhousedao/ph-clint-app").RemoveModelAction;
+        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;
+        setEnableChat: (input: import("@powerhousedao/ph-clint-app").SetEnableChatInput) => import("@powerhousedao/ph-clint-app").SetEnableChatAction;
+        addSupportedResource: (input: import("@powerhousedao/ph-clint-app").AddSupportedResourceInput) => import("@powerhousedao/ph-clint-app").AddSupportedResourceAction;
+        removeSupportedResource: (input: import("@powerhousedao/ph-clint-app").RemoveSupportedResourceInput) => import("@powerhousedao/ph-clint-app").RemoveSupportedResourceAction;
+        setProxyEnabled: (input: import("@powerhousedao/ph-clint-app").SetProxyEnabledInput) => import("@powerhousedao/ph-clint-app").SetProxyEnabledAction;
+        setObservabilityEnabled: (input: import("@powerhousedao/ph-clint-app").SetObservabilityEnabledInput) => import("@powerhousedao/ph-clint-app").SetObservabilityEnabledAction;
+        importSpec: (input: import("@powerhousedao/ph-clint-app").ImportSpecInput) => import("@powerhousedao/ph-clint-app").ImportSpecAction;
+        bumpVersion: (input: import("@powerhousedao/ph-clint-app").BumpVersionInput) => import("@powerhousedao/ph-clint-app").BumpVersionAction;
+        publishDev: (input: import("@powerhousedao/ph-clint-app").PublishDevInput) => import("@powerhousedao/ph-clint-app").PublishDevAction;
+        publishStaging: (input: import("@powerhousedao/ph-clint-app").PublishStagingInput) => import("@powerhousedao/ph-clint-app").PublishStagingAction;
+        publishProduction: (input: import("@powerhousedao/ph-clint-app").PublishProductionInput) => import("@powerhousedao/ph-clint-app").PublishProductionAction;
+        setPublishStatus: (input: import("@powerhousedao/ph-clint-app").SetPublishStatusInput) => import("@powerhousedao/ph-clint-app").SetPublishStatusAction;
+        addExternalSkill: (input: import("@powerhousedao/ph-clint-app").AddExternalSkillInput) => import("@powerhousedao/ph-clint-app").AddExternalSkillAction;
+        removeExternalSkill: (input: import("@powerhousedao/ph-clint-app").RemoveExternalSkillInput) => import("@powerhousedao/ph-clint-app").RemoveExternalSkillAction;
+        setExternalSkillName: (input: import("@powerhousedao/ph-clint-app").SetExternalSkillNameInput) => import("@powerhousedao/ph-clint-app").SetExternalSkillNameAction;
+        setExternalSkillGithubUrl: (input: import("@powerhousedao/ph-clint-app").SetExternalSkillGithubUrlInput) => import("@powerhousedao/ph-clint-app").SetExternalSkillGithubUrlAction;
+        addPowerhousePackage: (input: import("@powerhousedao/ph-clint-app").AddPowerhousePackageInput) => import("@powerhousedao/ph-clint-app").AddPowerhousePackageAction;
+        removePowerhousePackage: (input: import("@powerhousedao/ph-clint-app").RemovePowerhousePackageInput) => import("@powerhousedao/ph-clint-app").RemovePowerhousePackageAction;
+        addPackageDocumentType: (input: import("@powerhousedao/ph-clint-app").AddPackageDocumentTypeInput) => import("@powerhousedao/ph-clint-app").AddPackageDocumentTypeAction;
+        removePackageDocumentType: (input: import("@powerhousedao/ph-clint-app").RemovePackageDocumentTypeInput) => import("@powerhousedao/ph-clint-app").RemovePackageDocumentTypeAction;
+        setPackageVersion: (input: import("@powerhousedao/ph-clint-app").SetPackageVersionInput) => import("@powerhousedao/ph-clint-app").SetPackageVersionAction;
+        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;
+        setPowerhouseLevel: (input: import("@powerhousedao/ph-clint-app").SetPowerhouseLevelInput) => import("@powerhousedao/ph-clint-app").SetPowerhouseLevelAction;
+        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;
+        setPackageIdentifier: (input: import("@powerhousedao/ph-clint-app").SetPackageIdentifierInput) => import("@powerhousedao/ph-clint-app").SetPackageIdentifierAction;
+        setName: (name: string | {
+            name: string;
+        }) => import("document-model").SetNameAction;
+        setPreferredEditor: (input: string | null | {
+            preferredEditor: string | null;
+        }) => import("document-model").SetPreferredEditorAction;
+        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;
+}]>>;

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

@@ -0,0 +1,34 @@
+import path from 'node:path';
+import { defineCommand } from '../framework.js';
+import { z } from 'zod';
+import { detectLayout } from '@powerhousedao/ph-clint-dev';
+const inputSchema = z.object({
+    dir: z.string().optional().describe('Project root directory (default: cwd)'),
+    verbose: z.boolean().default(false),
+});
+export const build = defineCommand({
+    id: 'clint-project-build',
+    description: 'Build all packages in the project',
+    inputSchema,
+    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`);
+            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`);
+            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`);
+            const result = await runProcess('pnpm build', { cwd: layout?.cli ?? dir, timeout: 120_000 });
+            if (!result.success)
+                return { text: `Build failed.` };
+        }
+        return { text: 'Build complete.' };
+    },
+});