@powerhousedao/ph-clint-cli 0.1.0-dev.53 → 0.1.0-dev.54

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';

package/dist/codegen/write.js

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

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

@@ -16,8 +16,8 @@ import { defineCommand } from '../framework.js';
 import { z } from 'zod';
 import { clintProjectSpecSchema, } from '../spec/types.js';
 import { generateProject } from '../codegen/index.js';
-import { isDirEmptyEnough } from '../codegen/write.js';
-import { runPostGenActions } from '../codegen/actions.js';
+import { isDirEmptyEnough } from '@powerhousedao/ph-clint-dev/codegen/write';
+import { runPostGenActions } from '@powerhousedao/ph-clint-dev/codegen/actions';
 import { ensureSpecDocument } from '../spec/ensure-document.js';
 const inputSchema = z.object({
     dir: z

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

@@ -11,7 +11,7 @@ import { defineCommand } from '../framework.js';
 import { z } from 'zod';
 import { readProjectSpec } from '../spec/file.js';
 import { generateProject } from '../codegen/index.js';
-import { runPostGenActions } from '../codegen/actions.js';
+import { runPostGenActions } from '@powerhousedao/ph-clint-dev/codegen/actions';
 import { ensureSpecDocument } from '../spec/ensure-document.js';
 const inputSchema = z.object({
     dir: z

package/dist/commands/clint-skills-sync.d.ts

@@ -6,7 +6,7 @@ export declare const skillsSync: import("@powerhousedao/ph-clint").Command<z.Zod
     data?: undefined;
 } | {
     text: string;
-    data: import("../skills/sync.js").SyncResult;
+    data: import("@powerhousedao/ph-clint-dev/skills/sync").SyncResult;
 }, {
     model: string;
     devServicePort: number;

package/dist/commands/clint-skills-sync.js

@@ -7,7 +7,7 @@ import path from 'node:path';
 import { defineCommand } from '../framework.js';
 import { z } from 'zod';
 import { readProjectSpec } from '../spec/file.js';
-import { syncExternalSkills } from '../skills/sync.js';
+import { syncExternalSkills } from '@powerhousedao/ph-clint-dev/skills/sync';
 const inputSchema = z.object({
     dir: z
         .string()

package/dist/framework.js

@@ -23,7 +23,7 @@ export const configSchema = z.object({
         .describe('Port reserved for the impl project (Service B) `pnpm dev`'),
     phVersion: z
         .string()
-        .default('6.0.0-dev.170')
+        .default('latest')
         .describe('Pinned Powerhouse version used when emitting a new impl project'),
 });
 export const secretsSchema = z.object({

package/dist/skills/sync.d.ts

@@ -1,40 +1 @@
-import type { ExternalSkill } from '../spec/types.js';
-/** On-disk manifest entry (what is currently installed). */
-export interface ManifestEntry {
-    name: string;
-    githubUrl: string;
-}
-/** Persisted manifest — a simple JSON array. */
-export type SkillsManifest = ManifestEntry[];
-export interface SyncResult {
-    added: string[];
-    removed: string[];
-    unchanged: string[];
-}
-export interface SyncOptions {
-    /** Project root (CLI sub-tree when split layout). */
-    targetDir: string;
-    /** Desired state from the spec. */
-    desired: ExternalSkill[];
-    /** Optional log callback. */
-    log?: (msg: string) => void;
-}
-export declare function readManifest(targetDir: string): Promise<SkillsManifest>;
-/**
- * Compute the diff between desired (spec) and current (manifest) skills.
- *
- * Pure function — no I/O.
- */
-export declare function diffSkills(desired: ExternalSkill[], current: SkillsManifest): {
-    toAdd: ExternalSkill[];
-    toRemove: ManifestEntry[];
-    unchanged: string[];
-};
-/**
- * Synchronise external skills on disk to match the spec.
- *
- * - Clones missing skills via `git clone --depth 1`.
- * - Removes skills no longer in the spec.
- * - Updates the `.skills-manifest.json`.
- */
-export declare function syncExternalSkills(opts: SyncOptions): Promise<SyncResult>;
+export { type ManifestEntry, type SkillsManifest, type SyncResult, type SyncOptions, readManifest, diffSkills, syncExternalSkills, } from '@powerhousedao/ph-clint-dev/skills/sync';

package/dist/skills/sync.js

@@ -1,119 +1 @@
-/**
- * External skills synchronisation.
- *
- * Reads the desired external skills from a `ClintProjectSpec`, diffs them
- * against a `.skills-manifest.json` on disk, and runs `git clone` / `rm -rf`
- * to reconcile.  Each external skill ends up as a subdirectory of
- * `prompts/skills-ext/<name>/` so the build-skills pipeline picks it up.
- */
-import { spawn } from 'node:child_process';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-const MANIFEST_FILE = '.skills-manifest.json';
-const SKILLS_DIR = path.join('prompts', 'skills-ext');
-function manifestPath(targetDir) {
-    return path.join(targetDir, SKILLS_DIR, MANIFEST_FILE);
-}
-export async function readManifest(targetDir) {
-    try {
-        const raw = await fs.readFile(manifestPath(targetDir), 'utf8');
-        return JSON.parse(raw);
-    }
-    catch {
-        return [];
-    }
-}
-async function writeManifest(targetDir, manifest) {
-    const file = manifestPath(targetDir);
-    await fs.mkdir(path.dirname(file), { recursive: true });
-    await fs.writeFile(file, JSON.stringify(manifest, null, 2) + '\n', 'utf8');
-}
-function execGit(args, cwd) {
-    return new Promise((resolve, reject) => {
-        const proc = spawn('git', args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
-        let stderr = '';
-        if (proc.stderr) {
-            proc.stderr.on('data', (d) => {
-                stderr += d.toString();
-            });
-        }
-        proc.on('close', (code) => resolve({ code: code ?? 1, stderr }));
-        proc.on('error', (err) => reject(err));
-    });
-}
-/**
- * Compute the diff between desired (spec) and current (manifest) skills.
- *
- * Pure function — no I/O.
- */
-export function diffSkills(desired, current) {
-    const desiredMap = new Map(desired.map((s) => [s.name, s]));
-    const currentMap = new Map(current.map((s) => [s.name, s]));
-    const toAdd = [];
-    const toRemove = [];
-    const unchanged = [];
-    for (const [name, skill] of desiredMap) {
-        const existing = currentMap.get(name);
-        if (!existing) {
-            toAdd.push(skill);
-        }
-        else if (existing.githubUrl !== skill.githubUrl) {
-            // URL changed — remove old, add new.
-            toRemove.push(existing);
-            toAdd.push(skill);
-        }
-        else {
-            unchanged.push(name);
-        }
-    }
-    for (const [name, entry] of currentMap) {
-        if (!desiredMap.has(name)) {
-            toRemove.push(entry);
-        }
-    }
-    return { toAdd, toRemove, unchanged };
-}
-/**
- * Synchronise external skills on disk to match the spec.
- *
- * - Clones missing skills via `git clone --depth 1`.
- * - Removes skills no longer in the spec.
- * - Updates the `.skills-manifest.json`.
- */
-export async function syncExternalSkills(opts) {
-    const { targetDir, desired, log } = opts;
-    const skillsDir = path.join(targetDir, SKILLS_DIR);
-    await fs.mkdir(skillsDir, { recursive: true });
-    const current = await readManifest(targetDir);
-    const { toAdd, toRemove, unchanged } = diffSkills(desired, current);
-    const result = { added: [], removed: [], unchanged };
-    // Remove skills.
-    for (const entry of toRemove) {
-        const dir = path.join(skillsDir, entry.name);
-        log?.(`Removing skill "${entry.name}"…`);
-        await fs.rm(dir, { recursive: true, force: true });
-        result.removed.push(entry.name);
-    }
-    // Add skills.
-    for (const skill of toAdd) {
-        const dir = path.join(skillsDir, skill.name);
-        log?.(`Cloning skill "${skill.name}" from ${skill.githubUrl}…`);
-        // Ensure the target doesn't exist (re-add after URL change).
-        await fs.rm(dir, { recursive: true, force: true });
-        const { code, stderr } = await execGit(['clone', '--depth', '1', skill.githubUrl, skill.name], skillsDir);
-        if (code !== 0) {
-            log?.(`Warning: git clone failed for "${skill.name}": ${stderr.trim()}`);
-            continue;
-        }
-        // Remove .git dir — we don't want a nested repo.
-        await fs.rm(path.join(dir, '.git'), { recursive: true, force: true });
-        result.added.push(skill.name);
-    }
-    // Write updated manifest.
-    const newManifest = desired.map((s) => ({
-        name: s.name,
-        githubUrl: s.githubUrl,
-    }));
-    await writeManifest(targetDir, newManifest);
-    return result;
-}
+export { readManifest, diffSkills, syncExternalSkills, } from '@powerhousedao/ph-clint-dev/skills/sync';

package/dist/spec/ensure-document.js

@@ -28,30 +28,24 @@ export async function ensureSpecDocument(opts) {
         if (inDrive)
             return { docId: spec.documentId, created: false };
     }
-    // Reuse existing document if it's still in the reactor, otherwise create new
     let docId;
     if (spec.documentId) {
         try {
-            const existing = await reactor.client.get(spec.documentId);
-            if (existing) {
-                docId = spec.documentId;
-            }
-            else {
-                const newDoc = await reactor.client.createEmpty(DOCUMENT_TYPE);
-                docId = newDoc.header.id;
-            }
+            await reactor.client.get(spec.documentId);
+            docId = spec.documentId;
+            // Orphan recovery: doc exists in reactor but not in drive. Re-attach via
+            // addDocument; we can't retrofit CREATE/UPGRADE into the drive's stream.
+            await folders.addDocument(docId, `specs/${spec.name}`, spec.name);
         }
         catch {
-            const newDoc = await reactor.client.createEmpty(DOCUMENT_TYPE);
-            docId = newDoc.header.id;
+            const created = await folders.createDocument(DOCUMENT_TYPE, `specs/${spec.name}`, spec.name);
+            docId = created.documentId;
         }
     }
     else {
-        const newDoc = await reactor.client.createEmpty(DOCUMENT_TYPE);
-        docId = newDoc.header.id;
+        const created = await folders.createDocument(DOCUMENT_TYPE, `specs/${spec.name}`, spec.name);
+        docId = created.documentId;
     }
-    // Add to the drive's folder tree
-    await folders.addDocument(docId, `specs/${spec.name}`, spec.name);
     const importInput = specToImportInput(spec);
     await reactor.client.execute(docId, 'main', [importSpec(importInput)]);
     // Persist the link back to disk

package/dist/spec/file.d.ts

@@ -1,4 +1 @@
-import { type ClintProjectSpec } from './types.js';
-export declare function getSpecPath(projectDir: string): string;
-export declare function readProjectSpec(projectDir: string): Promise<ClintProjectSpec | null>;
-export declare function writeProjectSpec(projectDir: string, spec: ClintProjectSpec): Promise<void>;
+export { getSpecPath, readProjectSpec, writeProjectSpec, } from '@powerhousedao/ph-clint-dev/spec/file';

package/dist/spec/file.js

@@ -1,34 +1 @@
-/**
- * Persistence for `ClintProjectSpec`.
- * Stored at `{impl-project}/.ph/ph-clint-cli/project-spec.json`.
- */
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { clintProjectSpecSchema, } from './types.js';
-const SPEC_DIR = path.join('.ph', 'ph-clint-cli');
-const SPEC_FILE = 'project-spec.json';
-export function getSpecPath(projectDir) {
-    return path.join(projectDir, SPEC_DIR, SPEC_FILE);
-}
-function isEnoent(err) {
-    return (!!err &&
-        typeof err === 'object' &&
-        'code' in err &&
-        err.code === 'ENOENT');
-}
-export async function readProjectSpec(projectDir) {
-    try {
-        const raw = await fs.readFile(getSpecPath(projectDir), 'utf8');
-        return clintProjectSpecSchema.parse(JSON.parse(raw));
-    }
-    catch (err) {
-        if (isEnoent(err))
-            return null;
-        throw err;
-    }
-}
-export async function writeProjectSpec(projectDir, spec) {
-    const file = getSpecPath(projectDir);
-    await fs.mkdir(path.dirname(file), { recursive: true });
-    await fs.writeFile(file, JSON.stringify(spec, null, 2) + '\n', 'utf8');
-}
+export { getSpecPath, readProjectSpec, writeProjectSpec, } from '@powerhousedao/ph-clint-dev/spec/file';

package/dist/spec/types.d.ts

@@ -1,164 +1 @@
-/**
- * ClintProjectSpec — the in-memory shape that describes a ph-clint
- * implementation project. Persisted at
- * `{impl-project}/.ph/ph-clint-cli/project-spec.json` and consumed by
- * the code generator (src/codegen/).
- *
- * Intentionally minimal. Richer structure (services, skills, agents,
- * triggers, document-models) gets added in later phases as each
- * generator step actually needs it.
- */
-import { z } from 'zod';
-/**
- * Ordered Powerhouse integration level. Higher levels imply all lower ones:
- *   Disabled → Reactor → Switchboard → Connect
- */
-export declare const POWERHOUSE_LEVELS: readonly ["Disabled", "Reactor", "Switchboard", "Connect"];
-export declare const powerhouseLevelSchema: z.ZodDefault<z.ZodEnum<{
-    Disabled: "Disabled";
-    Reactor: "Reactor";
-    Switchboard: "Switchboard";
-    Connect: "Connect";
-}>>;
-export type PowerhouseLevel = z.infer<typeof powerhouseLevelSchema>;
-/** Check whether `level` is at least `threshold` in the ordered enum. */
-export declare function phAtLeast(level: PowerhouseLevel, threshold: PowerhouseLevel): boolean;
-export declare const agentModelSchema: z.ZodObject<{
-    id: z.ZodString;
-    isDefault: z.ZodBoolean;
-}, z.core.$strip>;
-export type AgentModel = z.infer<typeof agentModelSchema>;
-export declare const agentProfileSchema: z.ZodObject<{
-    id: z.ZodString;
-    title: z.ZodString;
-    content: z.ZodString;
-}, z.core.$strip>;
-export type AgentProfile = z.infer<typeof agentProfileSchema>;
-export declare const powerhousePackageSchema: z.ZodObject<{
-    id: z.ZodString;
-    packageName: z.ZodString;
-    documentTypes: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    version: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-}, z.core.$strip>;
-export type PowerhousePackage = z.infer<typeof powerhousePackageSchema>;
-export declare const externalSkillSchema: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    githubUrl: z.ZodString;
-}, z.core.$strip>;
-export type ExternalSkill = z.infer<typeof externalSkillSchema>;
-export declare const clintProjectSpecSchema: z.ZodObject<{
-    name: z.ZodString;
-    scope: z.ZodOptional<z.ZodString>;
-    version: z.ZodDefault<z.ZodString>;
-    description: z.ZodDefault<z.ZodString>;
-    features: z.ZodDefault<z.ZodObject<{
-        powerhouse: z.ZodDefault<z.ZodEnum<{
-            Disabled: "Disabled";
-            Reactor: "Reactor";
-            Switchboard: "Switchboard";
-            Connect: "Connect";
-        }>>;
-        mastra: z.ZodDefault<z.ZodObject<{
-            enabled: z.ZodDefault<z.ZodBoolean>;
-            agentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-            agentName: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-            agentDescription: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-            agentImage: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-            models: z.ZodDefault<z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                isDefault: z.ZodBoolean;
-            }, z.core.$strip>>>;
-            profiles: z.ZodDefault<z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                title: z.ZodString;
-                content: z.ZodString;
-            }, z.core.$strip>>>;
-            common: z.ZodDefault<z.ZodObject<{
-                enableChat: z.ZodDefault<z.ZodBoolean>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
-        routine: z.ZodDefault<z.ZodObject<{
-            enabled: z.ZodDefault<z.ZodBoolean>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    packages: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        packageName: z.ZodString;
-        documentTypes: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        version: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strip>>>;
-    externalSkills: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        name: z.ZodString;
-        githubUrl: z.ZodString;
-    }, z.core.$strip>>>;
-    deployment: z.ZodDefault<z.ZodObject<{
-        proxyEnabled: z.ZodDefault<z.ZodBoolean>;
-        supportedResources: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>;
-    documentId: z.ZodOptional<z.ZodString>;
-    documentType: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type ClintProjectSpec = z.infer<typeof clintProjectSpecSchema>;
-export type ClintProjectSpecInput = z.input<typeof clintProjectSpecSchema>;
-/** npm package name (e.g. `@scope/my-tool-cli` or `my-tool-cli`). */
-export declare function getPackageName(spec: ClintProjectSpec): string;
-/** bin name (strips -cli suffix, e.g. `my-tool-cli` → `my-tool`). */
-export declare function getBinName(spec: ClintProjectSpec): string;
-/**
- * Name of the CLI sub-folder when the project is split (Powerhouse enabled).
- * For flat projects this is irrelevant — callers use the project root directly.
- */
-export declare function getCliFolderName(spec: ClintProjectSpec): string;
-/**
- * Name of the reactor-package sub-folder when the project is split.
- */
-export declare function getAppFolderName(spec: ClintProjectSpec): string;
-/**
- * Flat list of all document types across all packages. Convenience for
- * codegen that needs to iterate every registered document type regardless
- * of which package provides it.
- */
-export declare function getAllDocumentTypes(spec: ClintProjectSpec): string[];
-/**
- * The app npm package name (`@scope/my-tool-app` or `my-tool-app`).
- * Matches what the document model reducer stores in `packages[].packageName`.
- */
-export declare function getAppPackageName(spec: ClintProjectSpec): string;
-/** Directory name for the app package (e.g. `my-tool-app`, no scope prefix). */
-export declare function getAppDirName(spec: ClintProjectSpec): string;
-/**
- * Folder slug for a documentType ID. The slug is the portion after the last
- * `/` (e.g. `powerhouse/ph-clint-project` → `ph-clint-project`). Matches the
- * convention used by Powerhouse's reactor-package codegen — each document
- * model lives at `document-models/<slug>/`.
- */
-export declare function getDocumentTypeSlug(documentType: string): string;
-/**
- * PascalCase export name for a documentType ID. Powerhouse's module
- * generator exports each module as `PascalCase(<slug>)` (e.g.
- * `powerhouse/ph-clint-project` → `PhClintProject`). The top-level reactor
- * package re-exports these names, so this helper gives codegen the string
- * it needs both for the import and the `defineRegistry` entry.
- */
-export declare function getDocumentTypeModuleName(documentType: string): string;
-/**
- * Returns true when a documentType entry contains glob wildcards (`*`).
- * Glob entries like `*​/*`, `powerhouse/*`, or `powerhouse/doc-*` are spec
- * shorthand meaning "all matching document types from this package" and
- * must be resolved at runtime rather than emitted as static imports.
- */
-export declare function isDocTypeGlob(documentType: string): boolean;
-/**
- * Convert a documentType glob pattern to a regex source string suitable
- * for embedding in a `/pattern/` literal.  Each `*` matches any non-`/`
- * characters. Forward slashes are escaped so the output is safe inside
- * `/.../`.
- *
- * Examples:
- *   `*​/*`            → `^[^\/]*\/[^\/]*$`   (any org, any name)
- *   `powerhouse/*`   → `^powerhouse\/[^\/]*$`
- *   `powerhouse/doc-*` → `^powerhouse\/doc-[^\/]*$`
- */
-export declare function docTypeGlobToRegex(pattern: string): string;
+export { POWERHOUSE_LEVELS, powerhouseLevelSchema, type PowerhouseLevel, phAtLeast, agentModelSchema, type AgentModel, agentProfileSchema, type AgentProfile, powerhousePackageSchema, type PowerhousePackage, externalSkillSchema, type ExternalSkill, clintProjectSpecSchema, type ClintProjectSpec, type ClintProjectSpecInput, getPackageName, getBinName, getCliFolderName, getAppFolderName, getAllDocumentTypes, getAppPackageName, getAppDirName, getDocumentTypeSlug, getDocumentTypeModuleName, isDocTypeGlob, docTypeGlobToRegex, } from '@powerhousedao/ph-clint-dev/spec';