@powerhousedao/ph-clint-cli 0.1.0-dev.57 → 0.1.0-dev.59

package/dist/codegen/builders/index.js

@@ -1,85 +1 @@
-/**
- * Registry of file builders. Each entry knows its own relative path (within
- * the CLI sub-tree) and a function that builds its content from the spec.
- *
- * Orchestrated by `codegen/index.ts` — it walks this registry, adjusts paths
- * for flat vs split layouts, and writes the files.
- */
-import { buildCliPackageJson } from './cli-package-json.js';
-import { buildCliTs } from './cli-ts.js';
-import { buildConfigTs } from './config-ts.js';
-import { buildMainTs } from './main-ts.js';
-import { buildTsconfigJson } from './tsconfig-json.js';
-import { buildJestConfigJs } from './jest-config-js.js';
-import { buildEslintConfigJs } from './eslint-config-js.js';
-import { buildGitignore } from './gitignore.js';
-import { buildMastraIndexTs } from './mastra-index-ts.js';
-import { buildBuildSkillsScript } from './build-skills-ts.js';
-import { buildAgentBaseMd } from './agent-base-md.js';
-import { buildAgentTs } from './agent-ts.js';
-import { buildDemoAgentTs } from './demo-agent-ts.js';
-import { buildFrameworkGenTs } from './framework-gen-ts.js';
-import { buildFrameworkTs } from './framework-ts.js';
-import { buildManifestJson } from './manifest-json.js';
-import { buildSmokeTestTs } from './smoke-test-ts.js';
-/**
- * Generate dynamic file builders for agent profile markdown files.
- * One file per profile in `prompts/agent-profiles/{id}.md`.
- */
-export function getProfileFileBuilders(spec) {
-    const { mastra } = spec.features;
-    if (!mastra.enabled || mastra.profiles.length === 0)
-        return [];
-    return mastra.profiles.map((profile) => ({
-        relativePath: `prompts/agent-profiles/${profile.id}.md`,
-        build: () => profile.content + '\n',
-    }));
-}
-export const CLI_FILE_BUILDERS = [
-    { relativePath: 'powerhouse.manifest.json', build: buildManifestJson },
-    { relativePath: 'package.json', build: buildCliPackageJson },
-    { relativePath: 'tsconfig.json', build: () => buildTsconfigJson() },
-    { relativePath: 'jest.config.js', build: () => buildJestConfigJs() },
-    { relativePath: 'eslint.config.js', build: () => buildEslintConfigJs() },
-    { relativePath: '.gitignore', build: () => buildGitignore() },
-    { relativePath: 'src/main.ts', build: () => buildMainTs() },
-    { relativePath: 'src/cli.ts', build: buildCliTs },
-    { relativePath: 'src/config.ts', build: buildConfigTs },
-    // User-owned outside markers; generated config/secrets inside markers.
-    { relativePath: 'src/framework.ts', build: buildFrameworkTs },
-    // Machine-owned; regenerated on every run. Null when no document types.
-    { relativePath: 'src/framework.gen.ts', build: buildFrameworkGenTs },
-    { relativePath: 'src/mastra/index.ts', build: buildMastraIndexTs },
-    { relativePath: 'scripts/build-skills.ts', build: () => buildBuildSkillsScript() },
-    {
-        relativePath: 'prompts/agent-profiles/AgentBase.md',
-        build: (spec) => (spec.features.mastra.profiles.length > 0 ? null : buildAgentBaseMd(spec)),
-    },
-    {
-        relativePath: 'src/agents/agent.ts',
-        build: (spec) => (spec.features.mastra.enabled ? buildAgentTs(spec) : null),
-    },
-    {
-        relativePath: 'src/agents/demo-agent.ts',
-        build: buildDemoAgentTs,
-    },
-    // Gitkeep placeholders so directories are tracked in git when otherwise empty.
-    { relativePath: 'src/commands/.gitkeep', build: () => '' },
-    { relativePath: 'src/services/.gitkeep', build: () => '' },
-    {
-        relativePath: 'src/triggers/.gitkeep',
-        build: (spec) => (spec.features.routine.enabled ? '' : ''),
-    },
-    {
-        relativePath: 'src/agents/.gitkeep',
-        build: (spec) => (spec.features.mastra.enabled ? null : ''),
-    },
-    { relativePath: 'prompts/skills-tpl/.gitkeep', build: () => '' },
-    { relativePath: 'prompts/skills-ext/.gitkeep', build: () => '' },
-    { relativePath: 'tests/smoke.test.ts', build: buildSmokeTestTs, initOnly: true },
-];
-export { buildCliPackageJson, buildCliTs, buildConfigTs, buildMainTs, buildTsconfigJson, buildJestConfigJs, buildEslintConfigJs, buildGitignore, buildMastraIndexTs, buildBuildSkillsScript, buildAgentBaseMd, buildAgentTs, buildDemoAgentTs, buildFrameworkGenTs, buildFrameworkTs, buildManifestJson, buildSmokeTestTs, };
-export { buildRootPackageJson } from './root-package-json.js';
-export { buildPublishConfigJs } from './publish-config-js.js';
-export { buildReadme } from './readme-md.js';
-export { buildAppIndexTs } from './app-index-ts.js';
+export { CLI_FILE_BUILDERS, getProfileFileBuilders, buildCliPackageJson, buildCliTs, buildConfigTs, buildMainTs, buildTsconfigJson, buildJestConfigJs, buildEslintConfigJs, buildGitignore, buildMastraIndexTs, buildBuildSkillsScript, buildAgentBaseMd, buildAgentTs, buildDemoAgentTs, buildFrameworkGenTs, buildFrameworkTs, buildManifestJson, buildSmokeTestTs, buildRootPackageJson, buildPublishConfigJs, buildReadme, buildAppIndexTs, } from '@powerhousedao/ph-clint-dev/codegen/builders';

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

@@ -0,0 +1,8 @@
+/**
+ * Builds the root `publish.config.ts`.
+ *
+ * Split-layout: a lockstep group with both app and cli packages.
+ * Single-layout: a single-package group at `.`.
+ */
+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,32 @@
+/**
+ * Builds the root `publish.config.ts`.
+ *
+ * Split-layout: a lockstep group with both app and cli packages.
+ * Single-layout: a single-package group at `.`.
+ */
+import { phAtLeast } from '../../spec/types.js';
+export function buildPublishConfigTs(spec) {
+    const split = phAtLeast(spec.features.powerhouse, 'Reactor');
+    // The publish pipeline appends the prerelease suffix (e.g. -dev.0), so we
+    // only store the base semver (M.m.p) here.
+    const baseVersion = spec.version.replace(/-.*$/, '');
+    const packages = split
+        ? `[
+        { path: '${spec.name}-app', category: 'app' },
+        { path: '${spec.name}-cli', category: 'cli' },
+      ]`
+        : `[
+        { path: '.', category: 'cli' },
+      ]`;
+    return `// Publish config — loaded by ph-clint's publish pipeline.
+// definePublishConfig is an identity function; a plain export is equivalent.
+export default {
+  groups: {
+    '${spec.name}': {
+      version: '${baseVersion}',
+      packages: ${packages},
+    },
+  },
+};
+`;
+}

package/dist/codegen/exec.d.ts

@@ -1,2 +1 @@
-/** Returns true if `command` is on PATH. */
-export declare function hasCommandOnPath(command: string): Promise<boolean>;
+export { hasCommandOnPath, getPhVersion, } from '@powerhousedao/ph-clint-dev/codegen/exec';

package/dist/codegen/exec.js

@@ -1,14 +1 @@
-/**
- * Small helpers for invoking external commands during code generation.
- */
-import { spawn } from 'node:child_process';
-/** Returns true if `command` is on PATH. */
-export async function hasCommandOnPath(command) {
-    return new Promise((resolve) => {
-        const child = spawn(process.platform === 'win32' ? 'where' : 'which', [command], {
-            stdio: 'ignore',
-        });
-        child.once('error', () => resolve(false));
-        child.once('close', (code) => resolve(code === 0));
-    });
-}
+export { hasCommandOnPath, getPhVersion, } from '@powerhousedao/ph-clint-dev/codegen/exec';

package/dist/codegen/generated.d.ts

@@ -1,17 +1 @@
-import { type ClintProjectSpec } from '../spec/types.js';
-export interface GeneratedState {
-    name: string;
-    scope: string | undefined;
-    cliFolderName: string;
-    appFolderName: string;
-    /** True once `ph init` has run successfully in the app dir. */
-    appInitialized: boolean;
-}
-export declare function getGeneratedPath(targetDir: string): string;
-export declare function readGeneratedState(targetDir: string): Promise<GeneratedState | null>;
-export declare function writeGeneratedState(targetDir: string, state: GeneratedState): Promise<void>;
-/**
- * Derive a `GeneratedState` from a spec. The `appInitialized` flag must be
- * supplied by the caller (it depends on filesystem state, not the spec).
- */
-export declare function generatedStateFromSpec(spec: ClintProjectSpec, appInitialized: boolean): GeneratedState;
+export { type GeneratedState, getGeneratedPath, readGeneratedState, writeGeneratedState, generatedStateFromSpec, } from '@powerhousedao/ph-clint-dev/codegen/generated';

package/dist/codegen/generated.js

@@ -1,49 +1 @@
-/**
- * Tracks the derived state from the last successful code generation.
- *
- * Stored at `{targetDir}/.ph/ph-clint-cli/generated.json`. Used to detect
- * folder renames (name/scope changes) and re-apply patches that depend on
- * the project identity.
- */
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { getAppFolderName, getCliFolderName, } from '../spec/types.js';
-const GEN_DIR = path.join('.ph', 'ph-clint-cli');
-const GEN_FILE = 'generated.json';
-export function getGeneratedPath(targetDir) {
-    return path.join(targetDir, GEN_DIR, GEN_FILE);
-}
-export async function readGeneratedState(targetDir) {
-    try {
-        const raw = await fs.readFile(getGeneratedPath(targetDir), 'utf8');
-        return JSON.parse(raw);
-    }
-    catch (err) {
-        if (err &&
-            typeof err === 'object' &&
-            'code' in err &&
-            err.code === 'ENOENT') {
-            return null;
-        }
-        throw err;
-    }
-}
-export async function writeGeneratedState(targetDir, state) {
-    const file = getGeneratedPath(targetDir);
-    await fs.mkdir(path.dirname(file), { recursive: true });
-    await fs.writeFile(file, JSON.stringify(state, null, 2) + '\n', 'utf8');
-}
-/**
- * Derive a `GeneratedState` from a spec. The `appInitialized` flag must be
- * supplied by the caller (it depends on filesystem state, not the spec).
- */
-export function generatedStateFromSpec(spec, appInitialized) {
-    const split = spec.features.powerhouse !== 'Disabled';
-    return {
-        name: spec.name,
-        scope: spec.scope,
-        cliFolderName: split ? getCliFolderName(spec) : '',
-        appFolderName: split ? getAppFolderName(spec) : '',
-        appInitialized,
-    };
-}
+export { getGeneratedPath, readGeneratedState, writeGeneratedState, generatedStateFromSpec, } from '@powerhousedao/ph-clint-dev/codegen/generated';

package/dist/codegen/hashes.d.ts

@@ -1,6 +1 @@
-export type HashRecord = Record<string, string>;
-export declare function getHashesPath(targetDir: string): string;
-export declare function hashContent(content: string): string;
-export declare function hashFile(filePath: string): Promise<string | null>;
-export declare function readHashes(targetDir: string): Promise<HashRecord>;
-export declare function writeHashes(targetDir: string, hashes: HashRecord): Promise<void>;
+export { type HashRecord, getHashesPath, hashContent, hashFile, readHashes, writeHashes, } from '@powerhousedao/ph-clint-dev/codegen/hashes';

package/dist/codegen/hashes.js

@@ -1,60 +1 @@
-/**
- * Per-file content hashes written by the generator so subsequent runs can
- * detect whether a previously-generated file has been hand-edited.
- *
- * Stored at `{targetDir}/.ph/ph-clint-cli/.hashes.json` alongside the project
- * spec. Keys are paths relative to the project root.
- */
-import crypto from 'node:crypto';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-const HASHES_DIR = path.join('.ph', 'ph-clint-cli');
-const HASHES_FILE = '.hashes.json';
-export function getHashesPath(targetDir) {
-    return path.join(targetDir, HASHES_DIR, HASHES_FILE);
-}
-export function hashContent(content) {
-    return crypto.createHash('sha256').update(content, 'utf8').digest('hex');
-}
-function isEnoent(err) {
-    return (!!err &&
-        typeof err === 'object' &&
-        'code' in err &&
-        err.code === 'ENOENT');
-}
-export async function hashFile(filePath) {
-    try {
-        const content = await fs.readFile(filePath, 'utf8');
-        return hashContent(content);
-    }
-    catch (err) {
-        if (isEnoent(err))
-            return null;
-        throw err;
-    }
-}
-export async function readHashes(targetDir) {
-    try {
-        const raw = await fs.readFile(getHashesPath(targetDir), 'utf8');
-        const parsed = JSON.parse(raw);
-        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-            return parsed;
-        }
-        return {};
-    }
-    catch (err) {
-        if (isEnoent(err))
-            return {};
-        throw err;
-    }
-}
-export async function writeHashes(targetDir, hashes) {
-    const file = getHashesPath(targetDir);
-    await fs.mkdir(path.dirname(file), { recursive: true });
-    // Sort keys for stable output across runs.
-    const sorted = {};
-    for (const key of Object.keys(hashes).sort()) {
-        sorted[key] = hashes[key];
-    }
-    await fs.writeFile(file, JSON.stringify(sorted, null, 2) + '\n', 'utf8');
-}
+export { getHashesPath, hashContent, hashFile, readHashes, writeHashes, } from '@powerhousedao/ph-clint-dev/codegen/hashes';

package/dist/codegen/markers.d.ts

@@ -1,36 +1 @@
-/**
- * Marker-region parsing for `@clint:begin {name}` / `@clint:end {name}`
- * comment blocks. Used in delta mode to splice freshly-generated regions
- * into an existing, user-edited file while preserving everything outside
- * the markers.
- *
- * The only syntactic requirement is that the markers are on their own lines,
- * as ordinary line comments (`//`). Indentation is preserved for output.
- */
-export interface MarkerRegion {
-    /** Region identifier (the text after `@clint:begin`). */
-    name: string;
-    /** Lines *between* the begin and end markers (exclusive). */
-    body: string[];
-    /** Indentation of the begin line — used when rewriting. */
-    indent: string;
-    /** Line index of the begin marker in the source. */
-    beginLine: number;
-    /** Line index of the end marker in the source. */
-    endLine: number;
-}
-/**
- * Parse every `@clint:begin {name}` … `@clint:end {name}` block in `source`.
- * Throws if markers are mismatched or unclosed.
- */
-export declare function parseMarkerRegions(source: string): MarkerRegion[];
-/**
- * Replace every region in `target` that also exists in `source` with the
- * `source` region's body. Leaves regions present in `target` but not `source`
- * untouched. Ignores regions in `source` missing from `target`.
- *
- * Returns the rewritten file content.
- */
-export declare function spliceMarkerRegions(target: string, source: string): string;
-/** Convenience — true if `content` contains at least one `@clint:begin`. */
-export declare function hasMarkers(content: string): boolean;
+export { type MarkerRegion, parseMarkerRegions, spliceMarkerRegions, hasMarkers, } from '@powerhousedao/ph-clint-dev/codegen/markers';

package/dist/codegen/markers.js

@@ -1,86 +1 @@
-/**
- * Marker-region parsing for `@clint:begin {name}` / `@clint:end {name}`
- * comment blocks. Used in delta mode to splice freshly-generated regions
- * into an existing, user-edited file while preserving everything outside
- * the markers.
- *
- * The only syntactic requirement is that the markers are on their own lines,
- * as ordinary line comments (`//`). Indentation is preserved for output.
- */
-const BEGIN_RE = /^([ \t]*)\/\/\s*@clint:begin\s+(\S+)\s*$/;
-const END_RE = /^([ \t]*)\/\/\s*@clint:end\s+(\S+)\s*$/;
-/**
- * Parse every `@clint:begin {name}` … `@clint:end {name}` block in `source`.
- * Throws if markers are mismatched or unclosed.
- */
-export function parseMarkerRegions(source) {
-    const lines = source.split('\n');
-    const regions = [];
-    let open = null;
-    let bodyStart = 0;
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        const begin = BEGIN_RE.exec(line);
-        if (begin) {
-            if (open) {
-                throw new Error(`nested @clint:begin ${begin[2]} at line ${i + 1} while ${open.name} is still open`);
-            }
-            open = { name: begin[2], indent: begin[1], beginLine: i };
-            bodyStart = i + 1;
-            continue;
-        }
-        const end = END_RE.exec(line);
-        if (end) {
-            if (!open) {
-                throw new Error(`@clint:end ${end[2]} at line ${i + 1} without matching begin`);
-            }
-            if (open.name !== end[2]) {
-                throw new Error(`@clint:end ${end[2]} at line ${i + 1} does not match open @clint:begin ${open.name}`);
-            }
-            regions.push({
-                name: open.name,
-                body: lines.slice(bodyStart, i),
-                indent: open.indent,
-                beginLine: open.beginLine,
-                endLine: i,
-            });
-            open = null;
-        }
-    }
-    if (open) {
-        throw new Error(`unterminated @clint:begin ${open.name}`);
-    }
-    return regions;
-}
-/**
- * Replace every region in `target` that also exists in `source` with the
- * `source` region's body. Leaves regions present in `target` but not `source`
- * untouched. Ignores regions in `source` missing from `target`.
- *
- * Returns the rewritten file content.
- */
-export function spliceMarkerRegions(target, source) {
-    const sourceRegions = parseMarkerRegions(source);
-    const sourceByName = new Map();
-    for (const r of sourceRegions)
-        sourceByName.set(r.name, r);
-    const targetRegions = parseMarkerRegions(target);
-    if (targetRegions.length === 0)
-        return target;
-    const lines = target.split('\n');
-    // Apply replacements from last to first so line indices stay valid.
-    const sorted = [...targetRegions].sort((a, b) => b.beginLine - a.beginLine);
-    for (const region of sorted) {
-        const fresh = sourceByName.get(region.name);
-        if (!fresh)
-            continue;
-        // Replace the body lines (exclusive of the begin/end marker lines).
-        const bodyLen = region.endLine - region.beginLine - 1;
-        lines.splice(region.beginLine + 1, bodyLen, ...fresh.body);
-    }
-    return lines.join('\n');
-}
-/** Convenience — true if `content` contains at least one `@clint:begin`. */
-export function hasMarkers(content) {
-    return /^[ \t]*\/\/\s*@clint:begin\s+\S+\s*$/m.test(content);
-}
+export { parseMarkerRegions, spliceMarkerRegions, hasMarkers, } from '@powerhousedao/ph-clint-dev/codegen/markers';

package/dist/codegen/scaffold.d.ts

@@ -1,72 +1 @@
-import type { ClintProjectSpec } from '../spec/types.js';
-import type { ProcessRunOptions } from '@powerhousedao/ph-clint';
-/**
- * Signature for the subprocess runner — matches CommandContext.runProcess.
- */
-type RunProcess = (command: string, opts?: Omit<ProcessRunOptions, 'onOutput'>) => Promise<{
-    success: boolean;
-    output: string;
-}>;
-export type { RunProcess };
-export interface PhInitOptions {
-    /** Absolute path to the project root. */
-    targetDir: string;
-    /** Absolute path to `{targetDir}/{name}-app` (exists with our placeholder). */
-    appDir: string;
-    spec: ClintProjectSpec;
-    /** Logger; defaults to noop. */
-    log?: (msg: string) => void;
-    /** Override `ph` binary name (for tests). */
-    binName?: string;
-    /** Subprocess runner — matches CommandContext.runProcess. */
-    runProcess: RunProcess;
-    /** Explicit Powerhouse version to pin `ph init` to (tag or semver). */
-    phVersion?: string;
-}
-export interface PhInitResult {
-    ran: boolean;
-    exitCode?: number;
-    reason?: string;
-}
-/**
- * Detect the installed `ph` CLI version by parsing `ph --version` output.
- * Returns the version string (e.g. '6.0.0-dev.194') or undefined if
- * detection fails.
- */
-export declare function getPhVersion(binName: string): string | undefined;
-export declare function runPhInit(options: PhInitOptions): Promise<PhInitResult>;
-/**
- * Patch the app `package.json` name to the scoped form (`@scope/name-app`).
- * Called after `ph init` and after name/scope renames.
- *
- * Returns `true` if the file was actually changed.
- */
-export declare function patchAppPackageName(appDir: string, spec: {
-    name: string;
-    scope?: string;
-}, log?: (msg: string) => void): Promise<boolean>;
-/**
- * Run `ph install <packages> --local --pnpm` in the app directory to register
- * external packages in `powerhouse.config.json`.
- */
-export declare function runPhInstallPackages(options: {
-    appDir: string;
-    packages: string[];
-    log?: (msg: string) => void;
-    runProcess: RunProcess;
-}): Promise<boolean>;
-export interface PnpmInstallOptions {
-    /** Directories to run `pnpm install` in, in order. */
-    dirs: string[];
-    log?: (msg: string) => void;
-    /** Override `pnpm` binary name (for tests). */
-    binName?: string;
-    /** Subprocess runner — matches CommandContext.runProcess. */
-    runProcess: RunProcess;
-}
-export interface PnpmInstallResult {
-    ran: string[];
-    skipped: string[];
-    reason?: string;
-}
-export declare function runPnpmInstall(options: PnpmInstallOptions): Promise<PnpmInstallResult>;
+export { type RunProcess, type PhInitOptions, type PhInitResult, getPhVersion, runPhInit, patchAppPackageName, type PnpmInstallOptions, type PnpmInstallResult, runPnpmInstall, runPhInstallPackages, } from '@powerhousedao/ph-clint-dev/codegen/scaffold';

package/dist/codegen/scaffold.js

@@ -1,150 +1 @@
-/**
- * Post-generation side-effects: invoke `ph init` to fill in the reactor
- * package skeleton, and run `pnpm install` in the relevant sub-projects.
- *
- * Both steps are opt-out (flags on the init command) and both tolerate
- * missing binaries — they never fail the init flow, only emit warnings.
- */
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { execFileSync } from 'node:child_process';
-import { hasCommandOnPath } from './exec.js';
-/**
- * Detect the installed `ph` CLI version by parsing `ph --version` output.
- * Returns the version string (e.g. '6.0.0-dev.194') or undefined if
- * detection fails.
- */
-export function getPhVersion(binName) {
-    try {
-        const output = execFileSync(binName, ['--version'], {
-            encoding: 'utf-8',
-            timeout: 5_000,
-        });
-        const match = output.match(/PH CMD version:\s*(\S+)/);
-        return match?.[1];
-    }
-    catch {
-        return undefined;
-    }
-}
-export async function runPhInit(options) {
-    const log = options.log ?? (() => { });
-    const binName = options.binName ?? 'ph';
-    const appFolder = path.basename(options.appDir);
-    // Guard: never re-init an already-initialized app directory.
-    try {
-        await fs.access(path.join(options.appDir, 'package.json'));
-        log(`App directory ${appFolder} already initialized — skipping ph init.`);
-        return { ran: false, reason: 'already-initialized' };
-    }
-    catch {
-        // No package.json — proceed with init.
-    }
-    if (!(await hasCommandOnPath(binName))) {
-        log(`Skipping \`${binName} init\` — \`${binName}\` is not on PATH. ` +
-            `Install @powerhousedao/ph-cli and re-run manually inside ${appFolder}/.`);
-        return { ran: false, reason: 'ph-not-on-path' };
-    }
-    // Pin ph init to the same version as the installed ph CLI, so the
-    // generated app uses matching Powerhouse packages.
-    const phVersion = options.phVersion ?? getPhVersion(binName);
-    const tags = ['dev', 'staging', 'latest'];
-    const versionArgs = phVersion
-        ? tags.includes(phVersion)
-            ? [`--${phVersion}`]
-            : ['--version', phVersion]
-        : ['--dev']; // fallback if detection fails
-    // `ph init {name}` creates a fresh directory beside the cwd. Our generator
-    // placed a `.gitkeep` + README.md placeholder there; clear it out so
-    // ph init has a blank slate to work with.
-    await fs.rm(options.appDir, { recursive: true, force: true });
-    const args = ['init', appFolder, ...versionArgs, '--pnpm'];
-    log(`Running \`${binName} init ${appFolder}\` (version: ${phVersion ?? 'auto'}) in ${options.targetDir} …`);
-    const result = await options.runProcess(`${binName} ${args.join(' ')}`, {
-        cwd: options.targetDir,
-        timeout: 300_000,
-    });
-    const exitCode = result.success ? 0 : 1;
-    if (!result.success) {
-        log(`\`${binName} init\` failed. ` +
-            'You can re-run it manually after resolving the issue.');
-    }
-    await patchScopedName(options, appFolder, log);
-    return { ran: true, exitCode };
-}
-/**
- * Patch the app `package.json` name to the scoped form (`@scope/name-app`).
- * Called after `ph init` and after name/scope renames.
- *
- * Returns `true` if the file was actually changed.
- */
-export async function patchAppPackageName(appDir, spec, log) {
-    const appFolder = path.basename(appDir);
-    const scopedName = spec.scope
-        ? `${spec.scope}/${appFolder}`
-        : appFolder;
-    const appPkgJsonPath = path.join(appDir, 'package.json');
-    try {
-        const raw = await fs.readFile(appPkgJsonPath, 'utf8');
-        const pkg = JSON.parse(raw);
-        if (pkg.name !== scopedName) {
-            pkg.name = scopedName;
-            if (spec.scope) {
-                pkg.publishConfig = { access: 'public' };
-            }
-            await fs.writeFile(appPkgJsonPath, JSON.stringify(pkg, null, 2) + '\n');
-            log?.(`Patched app package name to ${scopedName}`);
-            return true;
-        }
-        return false;
-    }
-    catch (err) {
-        log?.(`Warning: could not patch app package name: ${err instanceof Error ? err.message : String(err)}`);
-        return false;
-    }
-}
-async function patchScopedName(options, _appFolder, log) {
-    await patchAppPackageName(options.appDir, options.spec, log);
-}
-/**
- * Run `ph install <packages> --local --pnpm` in the app directory to register
- * external packages in `powerhouse.config.json`.
- */
-export async function runPhInstallPackages(options) {
-    const { appDir, packages, log = () => { }, runProcess } = options;
-    const binName = 'ph';
-    if (!(await hasCommandOnPath(binName))) {
-        log(`Skipping — \`${binName}\` is not on PATH.`);
-        return false;
-    }
-    const args = ['install', ...packages, '--local', '--pnpm'];
-    log(`Running \`${binName} install ${packages.join(' ')} --local\` in ${path.basename(appDir)} …`);
-    const result = await runProcess(`${binName} ${args.join(' ')}`, {
-        cwd: appDir,
-        timeout: 300_000,
-    });
-    return result.success;
-}
-export async function runPnpmInstall(options) {
-    const log = options.log ?? (() => { });
-    const binName = options.binName ?? 'pnpm';
-    if (!(await hasCommandOnPath(binName))) {
-        log(`Skipping \`${binName} install\` — \`${binName}\` is not on PATH. ` +
-            'Install pnpm and re-run manually.');
-        return { ran: [], skipped: options.dirs, reason: 'pnpm-not-on-path' };
-    }
-    const ran = [];
-    for (const dir of options.dirs) {
-        log(`Running \`${binName} install\` in ${dir} …`);
-        const result = await options.runProcess(`${binName} install`, {
-            cwd: dir,
-            timeout: 300_000,
-        });
-        if (!result.success) {
-            log(`\`${binName} install\` failed in ${dir}. ` +
-                'Retry manually once the underlying issue is resolved.');
-        }
-        ran.push(dir);
-    }
-    return { ran, skipped: [] };
-}
+export { getPhVersion, runPhInit, patchAppPackageName, runPnpmInstall, runPhInstallPackages, } from '@powerhousedao/ph-clint-dev/codegen/scaffold';

package/dist/codegen/write.d.ts

@@ -1,6 +1 @@
-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>;
+export { writeFileEnsuringDir, isDirEmptyEnough, } from '@powerhousedao/ph-clint-dev/codegen/write';