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

package/dist/cli.js

@@ -7,20 +7,26 @@
  * Everything outside the markers is user-editable and preserved.
  */
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { existsSync } from 'node:fs';
 import { defineCli, buildDefaultReactor } from '@powerhousedao/ph-clint';
-import { CLI_NAME, CLI_VERSION } from './config.js';
+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 { specChangeTrigger } from './triggers/spec-change.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');
+const appDir = path.resolve(CLI_ROOT, '../ph-clint-app');
+function resolveConnectAssets(dir) {
+    const assetsDir = path.join(dir, 'dist', 'connect');
+    return existsSync(path.join(assetsDir, 'index.html')) ? assetsDir : undefined;
+}
 export const cli = defineCli({
     name: CLI_NAME,
     version: CLI_VERSION,
@@ -28,10 +34,10 @@ export const cli = defineCli({
     configSchema,
     secretsSchema,
     // @clint:begin commands
-    commands: [init, regen],
+    commands: [init, regen, build, clintProjectPublish],
     // @clint:end commands
     // @clint:begin services
-    services: [],
+    services: [clintProject],
     // @clint:end services
     // @clint:begin triggers
     triggers: [specChangeTrigger],
@@ -71,7 +77,7 @@ cli.configureReactor({
         subscriptions: { documentTypes: ['powerhouse/ph-clint-project'] },
     }),
     switchboard: { enabled: true },
-    connect: { enabled: true, workdir: appDir },
+    connect: { enabled: true, workdir: appDir, assetsDir: resolveConnectAssets(appDir) },
 });
 // @clint:end reactor
 // @clint:begin mastra

package/dist/codegen/builders/cli-package-json.js

@@ -5,8 +5,36 @@
  * `{root}/{name}-cli/package.json`. Otherwise at `{root}/package.json`.
  */
 import { getBinName, getPackageName, } from '../../spec/types.js';
-/** Pinned version range for peer ph-clint packages emitted into generated projects. */
-const PH_CLINT_VERSION = '^0.1.0';
+import { CLI_VERSION } from '../../config.js';
+/**
+ * Derive a semver range from the running ph-clint-cli version that respects
+ * the dev / staging / production channel boundary. This is the version range
+ * emitted into *scaffolded* projects' package.json for @powerhousedao/ph-clint
+ * and @powerhousedao/ph-clint-dev dependencies.
+ *
+ * CLI_VERSION is the version of ph-clint-cli itself (read from its own
+ * package.json at startup). Since all framework packages share a lockstep
+ * version, this is also the correct base for the dependency range.
+ *
+ * Examples:
+ *   "0.1.0"            → "^0.1.0"            (production — stable only)
+ *   "0.1.0-staging.2"  → "^0.1.0-staging.0"  (staging + stable)
+ *   "0.1.0-dev.4"      → "^0.1.0-dev.0"      (dev + staging + stable)
+ *
+ * This works because semver orders prereleases alphabetically:
+ * dev.N < staging.N < release. A caret range starting at dev.0 naturally
+ * upgrades through staging to production.
+ */
+function phClintRange(version) {
+    const match = /^(\d+\.\d+\.\d+)(?:-([a-z]+)\.\d+)?/.exec(version);
+    if (!match)
+        return `^${version}`;
+    const base = match[1];
+    const channel = match[2]; // "dev", "staging", or undefined
+    return channel ? `^${base}-${channel}.0` : `^${base}`;
+}
+/** Version range for @powerhousedao/ph-clint{,-dev} deps in scaffolded projects. */
+const PH_CLINT_VERSION = phClintRange(CLI_VERSION);
 const POWERHOUSE_VERSION = '6.0.0-dev.170';
 export function buildCliPackageJson(spec) {
     const { mastra, powerhouse } = spec.features;
@@ -15,7 +43,7 @@ export function buildCliPackageJson(spec) {
         : getPackageName(spec);
     const bin = getBinName(spec);
     const dependencies = {
-        'ph-clint': PH_CLINT_VERSION,
+        '@powerhousedao/ph-clint': PH_CLINT_VERSION,
         zod: '^4.3.6',
     };
     if (mastra.enabled) {
@@ -43,7 +71,6 @@ export function buildCliPackageJson(spec) {
         scripts['mastra:build'] = 'mastra build';
         scripts['mastra:start'] = 'mastra start';
     }
-    scripts['publish:npm'] = 'pnpm build && pnpm publish --no-git-checks';
     const pkg = {
         name: pkgName,
         version: spec.version,
@@ -59,7 +86,7 @@ export function buildCliPackageJson(spec) {
         '@jest/globals': '^30.2.0',
         '@types/node': '^25.5.2',
         jest: '^30.2.0',
-        'ph-clint-dev': PH_CLINT_VERSION,
+        '@powerhousedao/ph-clint-dev': PH_CLINT_VERSION,
         'ts-jest': '^29.4.6',
         tsx: '^4.19.0',
         typescript: '^6.0.2',

package/dist/codegen/builders/cli-ts.js

@@ -10,13 +10,13 @@ export function buildCliTs(spec) {
     lines.push(' */');
     if (powerhouse.enabled) {
         lines.push(`import path from 'node:path';`);
-        lines.push(`import { fileURLToPath } from 'node:url';`);
+        lines.push(`import { existsSync } from 'node:fs';`);
         lines.push(`import { defineCli, buildDefaultReactor } from '@powerhousedao/ph-clint';`);
     }
     else {
         lines.push(`import { defineCli } from '@powerhousedao/ph-clint';`);
     }
-    lines.push(`import { CLI_NAME, CLI_VERSION } from './config.js';`);
+    lines.push(`import { CLI_NAME, CLI_VERSION${powerhouse.enabled ? ', CLI_ROOT' : ''} } from './config.js';`);
     lines.push(`import { configSchema, secretsSchema } from './framework.js';`);
     lines.push('');
     lines.push('// @clint:begin imports');
@@ -29,9 +29,15 @@ export function buildCliTs(spec) {
     lines.push('// @clint:end imports');
     lines.push('');
     if (powerhouse.enabled) {
-        lines.push(`const __dirname = path.dirname(fileURLToPath(import.meta.url));`);
-        lines.push(`const appDir = path.resolve(__dirname, '../../${spec.name}-app');`);
+        lines.push(`const appDir = path.resolve(CLI_ROOT, '../${spec.name}-app');`);
         lines.push('');
+        if (powerhouse.connect) {
+            lines.push('function resolveConnectAssets(dir: string): string | undefined {');
+            lines.push("  const assetsDir = path.join(dir, 'dist', 'connect');");
+            lines.push("  return existsSync(path.join(assetsDir, 'index.html')) ? assetsDir : undefined;");
+            lines.push('}');
+            lines.push('');
+        }
     }
     lines.push('export const cli = defineCli({');
     lines.push('  name: CLI_NAME,');
@@ -71,10 +77,21 @@ export function buildCliTs(spec) {
     lines.push('');
     lines.push('  // @clint:begin interactive');
     lines.push('  interactive: {');
-    lines.push(`    welcome: ({ workdir }) =>`);
+    const ctxArgs = [];
+    if (powerhouse.enabled && (powerhouse.switchboard || powerhouse.connect)) {
+        ctxArgs.push('config');
+    }
+    ctxArgs.push('workdir');
+    lines.push(`    welcome: ({ ${ctxArgs.join(', ')} }) =>`);
     lines.push('      [');
     lines.push('        `${CLI_NAME} v${CLI_VERSION}`,');
     lines.push('        `Workdir: ${workdir}`,');
+    if (powerhouse.enabled && powerhouse.switchboard) {
+        lines.push('        `Switchboard: http://localhost:${config.switchboardPort}`,');
+    }
+    if (powerhouse.enabled && powerhouse.connect) {
+        lines.push('        `Connect:     http://localhost:${config.connectPort}`,');
+    }
     lines.push("        '',");
     if (mastra.enabled) {
         lines.push("        'Type a message to talk to the agent, or /help for commands.',");
@@ -96,7 +113,12 @@ export function buildCliTs(spec) {
         lines.push(`      drive: { name: '${spec.name}' },`);
         lines.push('    }),');
         lines.push(`  switchboard: { enabled: ${String(powerhouse.switchboard)} },`);
-        lines.push(`  connect: { enabled: ${String(powerhouse.connect)}, workdir: appDir },`);
+        if (powerhouse.connect) {
+            lines.push(`  connect: { enabled: true, workdir: appDir, assetsDir: resolveConnectAssets(appDir) },`);
+        }
+        else {
+            lines.push(`  connect: { enabled: false },`);
+        }
         lines.push('});');
     }
     lines.push('// @clint:end reactor');

package/dist/codegen/builders/config-ts.js

@@ -1,21 +1,17 @@
-/**
- * Builds `src/config.ts` — CLI identity constants (name, version, project
- * root path). The Zod `configSchema` / `secretsSchema` are emitted by
- * `buildFrameworkTs` into `src/framework.ts` (user-owned, init-only) so users
- * can extend them without fighting the generator.
- */
-import { getBinName, } from '../../spec/types.js';
 export function buildConfigTs(spec) {
-    const cliName = getBinName(spec);
+    const hasCustomBin = !!spec.bin;
     const lines = [];
-    lines.push(`import path from 'node:path';`);
-    lines.push(`import { fileURLToPath } from 'node:url';`);
+    lines.push(`import { readPackageInfo } from '@powerhousedao/ph-clint';`);
     lines.push('');
-    lines.push('/** CLI name — used for config resolution, env var prefixing, and .ph/ paths. */');
-    lines.push(`export const CLI_NAME = '${cliName}';`);
-    lines.push(`export const CLI_VERSION = '${spec.version}';`);
+    lines.push('const pkg = readPackageInfo(import.meta.url);');
     lines.push('');
-    lines.push('/** Project root — resolved from this file location. */');
-    lines.push('export const PROJECT_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), \'..\');');
+    lines.push('export const CLI_ROOT = pkg.root;');
+    if (hasCustomBin) {
+        lines.push(`export const CLI_NAME = '${spec.bin}';`);
+    }
+    else {
+        lines.push(`export const CLI_NAME = pkg.name.replace(/-cli$/, '');`);
+    }
+    lines.push('export const CLI_VERSION = pkg.version;');
     return lines.join('\n') + '\n';
 }

package/dist/codegen/builders/framework-gen-ts.js

@@ -33,7 +33,7 @@ export function buildFrameworkGenTs(spec) {
     lines.push('/**');
     lines.push(' * THIS FILE IS GENERATED BY ph-clint-cli. DO NOT EDIT.');
     lines.push(' *');
-    lines.push(' * Regenerated on every `ph-clint regen` and on every spec-change');
+    lines.push(' * Regenerated on every `ph-clint clint-project-regen` and on every spec-change');
     lines.push(' * tick. Put custom bindings in `framework.ts`, not here — edits to');
     lines.push(' * this file will be overwritten.');
     lines.push(' */');

package/dist/codegen/builders/index.d.ts

@@ -39,5 +39,6 @@ export interface FileBuilder {
 export declare const CLI_FILE_BUILDERS: FileBuilder[];
 export { buildCliPackageJson, buildCliTs, buildConfigTs, buildMainTs, buildTsconfigJson, buildJestConfigJs, buildEslintConfigJs, buildGitignore, buildMastraIndexTs, buildBuildSkillsScript, buildAgentBaseMd, buildAgentTs, buildFrameworkGenTs, buildFrameworkTs, };
 export { buildRootPackageJson } from './root-package-json.js';
+export { buildPublishConfigTs } from './publish-config-ts.js';
 export { buildReadme } from './readme-md.js';
 export { buildAppIndexTs } from './app-index-ts.js';

package/dist/codegen/builders/index.js

@@ -56,5 +56,6 @@ export const CLI_FILE_BUILDERS = [
 ];
 export { buildCliPackageJson, buildCliTs, buildConfigTs, buildMainTs, buildTsconfigJson, buildJestConfigJs, buildEslintConfigJs, buildGitignore, buildMastraIndexTs, buildBuildSkillsScript, buildAgentBaseMd, buildAgentTs, buildFrameworkGenTs, buildFrameworkTs, };
 export { buildRootPackageJson } from './root-package-json.js';
+export { buildPublishConfigTs } from './publish-config-ts.js';
 export { buildReadme } from './readme-md.js';
 export { buildAppIndexTs } from './app-index-ts.js';

package/dist/codegen/builders/publish-config-ts.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Builds the root `publish.config.ts` for split-layout projects.
+ * Defines a single lockstep group containing both the app and cli packages.
+ */
+import { type ClintProjectSpec } from '../../spec/types.js';
+export declare function buildPublishConfigTs(spec: ClintProjectSpec): string;

package/dist/codegen/builders/publish-config-ts.js

@@ -0,0 +1,18 @@
+export function buildPublishConfigTs(spec) {
+    const app = `${spec.name}-app`;
+    const cli = `${spec.name}-cli`;
+    return `import { definePublishConfig } from '@powerhousedao/ph-clint-dev/publish';
+
+export default definePublishConfig({
+  groups: {
+    '${spec.name}': {
+      version: '${spec.version}',
+      packages: [
+        { path: '${app}', category: 'app' },
+        { path: '${cli}', category: 'cli' },
+      ],
+    },
+  },
+});
+`;
+}

package/dist/codegen/builders/readme-md.js

@@ -30,7 +30,7 @@ export function buildReadme(spec) {
     lines.push('## Regenerate');
     lines.push('');
     lines.push('Toggle features or update metadata in `.ph/ph-clint-cli/project-spec.json`,');
-    lines.push('then re-run `ph-clint` to regenerate.');
+    lines.push('then re-run `ph-clint clint-project-regen` to regenerate.');
     lines.push('');
     if (powerhouse.enabled) {
         lines.push('## Split layout');

package/dist/codegen/builders/root-package-json.d.ts

@@ -2,6 +2,9 @@
  * Builds the *root* `package.json` for split-layout projects (Powerhouse
  * enabled). A plain passthrough — deliberately no pnpm workspaces because
  * they interfere with `{name}-app`'s own `pnpm build`.
+ *
+ * Uses `pnpm --prefix <dir>` for all orchestration scripts — no cwd mutation.
+ * Build order: app first, then cli (cli depends on app via `file:` dep).
  */
 import { type ClintProjectSpec } from '../../spec/types.js';
 export declare function buildRootPackageJson(spec: ClintProjectSpec): string;

package/dist/codegen/builders/root-package-json.js

@@ -2,26 +2,39 @@
  * Builds the *root* `package.json` for split-layout projects (Powerhouse
  * enabled). A plain passthrough — deliberately no pnpm workspaces because
  * they interfere with `{name}-app`'s own `pnpm build`.
+ *
+ * Uses `pnpm --prefix <dir>` for all orchestration scripts — no cwd mutation.
+ * Build order: app first, then cli (cli depends on app via `file:` dep).
  */
 import { getPackageName, } from '../../spec/types.js';
 export function buildRootPackageJson(spec) {
     const cli = `${spec.name}-cli`;
     const app = `${spec.name}-app`;
+    const prefix = (dir, cmd) => `pnpm --prefix ${dir} ${cmd}`;
+    const both = (cmd) => `${prefix(app, cmd)} && ${prefix(cli, cmd)}`;
+    const connectEnabled = spec.features.powerhouse.enabled && spec.features.powerhouse.connect;
+    const buildScript = connectEnabled
+        ? `${prefix(app, 'build')} && ${prefix(app, 'connect:build')} && ${prefix(cli, 'build')}`
+        : both('build');
+    const scripts = {
+        install: both('install'),
+        build: buildScript,
+        test: both('test'),
+        dev: prefix(cli, 'dev'),
+        start: prefix(cli, 'start'),
+        lint: prefix(cli, 'lint'),
+        'app:dev': prefix(app, 'dev'),
+        'cli:dev': prefix(cli, 'dev'),
+        'publish:dev': `${prefix(cli, 'exec ph-publish')} dev -c ./publish.config.ts`,
+        'publish:staging': `${prefix(cli, 'exec ph-publish')} staging -c ./publish.config.ts`,
+        'publish:production': `${prefix(cli, 'exec ph-publish')} production -c ./publish.config.ts`,
+    };
     const pkg = {
         name: getPackageName(spec),
         version: spec.version,
         private: true,
         ...(spec.description ? { description: spec.description } : {}),
-        scripts: {
-            install: `cd ${app} && pnpm install && cd ../${cli} && pnpm install`,
-            build: `cd ${app} && pnpm build && cd ../${cli} && pnpm build`,
-            dev: `cd ${cli} && pnpm dev`,
-            start: `cd ${cli} && pnpm start`,
-            test: `cd ${app} && pnpm test && cd ../${cli} && pnpm test`,
-            lint: `cd ${cli} && pnpm lint`,
-            'app:dev': `cd ${app} && pnpm dev`,
-            'cli:dev': `cd ${cli} && pnpm dev`,
-        },
+        scripts,
     };
     return JSON.stringify(pkg, null, 2) + '\n';
 }

package/dist/codegen/index.js

@@ -35,7 +35,7 @@ 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';
+import { CLI_FILE_BUILDERS, buildReadme, buildRootPackageJson, buildPublishConfigTs, buildAppIndexTs, } from './builders/index.js';
 /**
  * Generate / reconcile a project at `targetDir` from the given spec.
  */
@@ -106,6 +106,12 @@ function planFiles(spec, targetDir) {
             absolutePath: rootPkg,
             content: buildRootPackageJson(spec),
         });
+        const publishConfig = path.join(targetDir, 'publish.config.ts');
+        planned.push({
+            relativePath: 'publish.config.ts',
+            absolutePath: publishConfig,
+            content: buildPublishConfigTs(spec),
+        });
         const appGitkeep = path.join(appDir, '.gitkeep');
         planned.push({
             relativePath: path.relative(targetDir, appGitkeep),

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

@@ -0,0 +1,7 @@
+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;
+}, Record<string, unknown>>;

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

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

package/dist/commands/clint-project-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/clint-project-init.js

@@ -0,0 +1,168 @@
+/**
+ * `ph-clint clint-project-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: 'clint-project-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 clint-project-regen` to regenerate.');
+        return {
+            text: next.join('\n'),
+            data: { targetDir, spec, fileCount: result.files.length },
+        };
+    },
+});

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

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export declare const clintProjectPublish: import("@powerhousedao/ph-clint").Command<z.ZodObject<{
+    tag: z.ZodEnum<{
+        dev: "dev";
+        staging: "staging";
+        production: "production";
+    }>;
+    dir: z.ZodOptional<z.ZodString>;
+    dryRun: z.ZodDefault<z.ZodBoolean>;
+    skipBuild: z.ZodDefault<z.ZodBoolean>;
+    verbose: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>, {
+    text: string;
+    data: import("@powerhousedao/ph-clint-dev/publish").PublishResult;
+}, Record<string, unknown>>;

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

@@ -0,0 +1,71 @@
+import path from 'node:path';
+import { defineCommand } from '@powerhousedao/ph-clint';
+import { z } from 'zod';
+import { resolvePublishPlan, buildPackages, publishPackages, } from '@powerhousedao/ph-clint-dev/publish';
+const inputSchema = z.object({
+    tag: z.enum(['dev', 'staging', 'production']).describe('Release channel'),
+    dir: z.string().optional().describe('Project root directory'),
+    dryRun: z.boolean().default(false).describe('Preview without publishing'),
+    skipBuild: z.boolean().default(false),
+    verbose: z.boolean().default(false),
+});
+function formatPlanPreview(plan) {
+    const lines = [];
+    const distTag = plan.tag === 'production' ? 'latest' : plan.tag;
+    lines.push(`Publish plan:`);
+    lines.push(`  Group:    ${plan.groupName}`);
+    lines.push(`  Version:  ${plan.version}`);
+    lines.push(`  Tag:      ${distTag}`);
+    lines.push(`  Registry: ${plan.registry}`);
+    lines.push(`  Packages:`);
+    for (const pkg of plan.packages) {
+        lines.push(`    - ${pkg.name}`);
+    }
+    return lines.join('\n');
+}
+export const clintProjectPublish = defineCommand({
+    id: 'clint-project-publish',
+    description: 'Publish project packages to npm',
+    inputSchema,
+    execute: async (input, { workdir, stdout }) => {
+        const dir = path.resolve(input.dir ?? workdir);
+        const logLines = [];
+        const log = (msg) => {
+            logLines.push(msg);
+            stdout(msg + '\n');
+        };
+        // 1. Resolve plan
+        const plan = await resolvePublishPlan({
+            tag: input.tag,
+            configPath: undefined, // auto-discover from dir
+            skipGitCheck: input.dryRun,
+            log,
+        });
+        // 2. Show preview
+        stdout(formatPlanPreview(plan) + '\n');
+        // 3. Build
+        if (!input.skipBuild) {
+            await buildPackages(plan, { verbose: input.verbose, log });
+        }
+        // 4. Publish (or dry-run)
+        const result = await publishPackages(plan, {
+            dryRun: input.dryRun,
+            verbose: input.verbose,
+            log,
+        });
+        if (result.success) {
+            return {
+                text: result.dryRun
+                    ? `Dry run complete — ${plan.packages.length} packages validated at ${result.version}.`
+                    : `Published ${result.published.length} packages at ${result.version}.`,
+                data: result,
+            };
+        }
+        else {
+            return {
+                text: `Publish failed. Published: ${result.published.length}, Failed: ${result.failed.length}.`,
+                data: result,
+            };
+        }
+    },
+});

package/dist/commands/clint-project-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/clint-project-regen.js

@@ -0,0 +1,68 @@
+/**
+ * `ph-clint clint-project-regen` — reconcile an existing project against its persisted
+ * spec. Equivalent to running the generator in update mode.
+ *
+ * Run inside a project directory (or pass `--dir`). If the spec has flipped
+ * `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: 'clint-project-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 clint-project-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

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

package/dist/config.js

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

package/dist/framework.gen.js

@@ -1,7 +1,7 @@
 /**
  * THIS FILE IS GENERATED BY ph-clint-cli. DO NOT EDIT.
  *
- * Regenerated on every `ph-clint regen` and on every spec-change tick.
+ * Regenerated on every `ph-clint clint-project-regen` and on every spec-change tick.
  * Put custom bindings in `framework.ts`, not here — edits to this file
  * will be overwritten.
  */

package/dist/services/clint-project.d.ts

@@ -0,0 +1 @@
+export declare const clintProject: import("@powerhousedao/ph-clint").ServiceDefinition<Record<string, unknown>>;

package/dist/services/clint-project.js

@@ -0,0 +1,47 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { defineService, checkWorkdir } from '@powerhousedao/ph-clint';
+export const clintProject = defineService({
+    id: 'clint-project',
+    name: 'Clint Project',
+    description: 'Development server for a ph-clint implementation project',
+    command: () => 'pnpm dev',
+    readiness: {
+        patterns: [{
+                name: 'cli-ready',
+                pattern: /Interactive mode started|ready/i,
+                captures: {},
+            }],
+        timeout: 30_000,
+    },
+    preflight: [
+        checkWorkdir((cwd) => {
+            const pkg = path.join(cwd, 'package.json');
+            if (!fs.existsSync(pkg))
+                return false;
+            try {
+                const json = JSON.parse(fs.readFileSync(pkg, 'utf8'));
+                return !!json.dependencies?.['@powerhousedao/ph-clint']
+                    || !!json.scripts?.dev;
+            }
+            catch {
+                return false;
+            }
+        }, 'Not a ph-clint project directory', 'Use --workdir to point to a ph-clint project root'),
+    ],
+    projectScanner: {
+        isProjectFolder: (p) => {
+            const pkg = path.join(p, 'package.json');
+            if (!fs.existsSync(pkg))
+                return false;
+            try {
+                const json = JSON.parse(fs.readFileSync(pkg, 'utf8'));
+                return !!json.dependencies?.['@powerhousedao/ph-clint'];
+            }
+            catch {
+                return false;
+            }
+        },
+    },
+    restart: { enabled: false, maxRetries: 0, delay: 0 },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powerhousedao/ph-clint-cli",
-  "version": "0.1.0-dev.0",
+  "version": "0.1.0-dev.10",
   "publishConfig": {
     "access": "public"
   },
@@ -22,12 +22,11 @@
     "lint": "eslint src",
     "mastra:dev": "mastra dev",
     "mastra:build": "mastra build",
-    "mastra:start": "mastra start",
-    "publish:npm": "pnpm build && pnpm publish --no-git-checks"
+    "mastra:start": "mastra start"
   },
   "dependencies": {
-    "@powerhousedao/ph-clint": "^0.1.0-dev.0",
-    "@powerhousedao/ph-clint-app": "^0.1.0-dev.0",
+    "@powerhousedao/ph-clint": "^0.1.0-dev.10",
+    "@powerhousedao/ph-clint-app": "^0.1.0-dev.10",
     "@mastra/core": "^1.22.0",
     "@mastra/libsql": "^1.7.4",
     "@mastra/memory": "^1.13.1",
@@ -38,6 +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.10",
     "zod": "^4.3.6"
   },
   "pnpm": {
@@ -49,7 +49,6 @@
     "@jest/globals": "^30.2.0",
     "@types/node": "^25.5.2",
     "jest": "^30.2.0",
-    "@powerhousedao/ph-clint-dev": "^0.1.0-dev.0",
     "ts-jest": "^29.4.6",
     "tsx": "^4.19.0",
     "typescript": "^6.0.2"