@powerhousedao/ph-clint-cli 0.1.0-dev.75 → 0.1.0-dev.77

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

@@ -76,6 +76,9 @@ export declare const clintProjectPublish: import("@powerhousedao/ph-clint").Comm
         setName: (name: string | {
             name: string;
         }) => import("document-model").SetNameAction;
+        setPreferredEditor: (input: string | null | {
+            preferredEditor: string | null;
+        }) => import("document-model").SetPreferredEditorAction;
         undo: (count?: number, scope?: string) => import("document-model").UndoAction;
         redo: (count?: number, scope?: string) => import("document-model").RedoAction;
         prune: (start?: number, end?: number, scope?: string) => import("document-model").SchemaPruneAction;

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

@@ -78,6 +78,9 @@ export declare const regen: import("@powerhousedao/ph-clint").Command<z.ZodObjec
         setName: (name: string | {
             name: string;
         }) => import("document-model").SetNameAction;
+        setPreferredEditor: (input: string | null | {
+            preferredEditor: string | null;
+        }) => import("document-model").SetPreferredEditorAction;
         undo: (count?: number, scope?: string) => import("document-model").UndoAction;
         redo: (count?: number, scope?: string) => import("document-model").RedoAction;
         prune: (start?: number, end?: number, scope?: string) => import("document-model").SchemaPruneAction;

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

@@ -70,6 +70,9 @@ export declare const skillsSync: import("@powerhousedao/ph-clint").Command<z.Zod
         setName: (name: string | {
             name: string;
         }) => import("document-model").SetNameAction;
+        setPreferredEditor: (input: string | null | {
+            preferredEditor: string | null;
+        }) => import("document-model").SetPreferredEditorAction;
         undo: (count?: number, scope?: string) => import("document-model").UndoAction;
         redo: (count?: number, scope?: string) => import("document-model").RedoAction;
         prune: (start?: number, end?: number, scope?: string) => import("document-model").SchemaPruneAction;

package/dist/framework.d.ts

@@ -88,6 +88,9 @@ export declare const defineCommand: <TInput extends z.ZodType, TOutput = unknown
             setName: (name: string | {
                 name: string;
             }) => import("document-model").SetNameAction;
+            setPreferredEditor: (input: string | null | {
+                preferredEditor: string | null;
+            }) => import("document-model").SetPreferredEditorAction;
             undo: (count?: number, scope?: string) => import("document-model").UndoAction;
             redo: (count?: number, scope?: string) => import("document-model").RedoAction;
             prune: (start?: number, end?: number, scope?: string) => import("document-model").SchemaPruneAction;
@@ -162,6 +165,9 @@ export declare const defineCommand: <TInput extends z.ZodType, TOutput = unknown
         setName: (name: string | {
             name: string;
         }) => import("document-model").SetNameAction;
+        setPreferredEditor: (input: string | null | {
+            preferredEditor: string | null;
+        }) => import("document-model").SetPreferredEditorAction;
         undo: (count?: number, scope?: string) => import("document-model").UndoAction;
         redo: (count?: number, scope?: string) => import("document-model").RedoAction;
         prune: (start?: number, end?: number, scope?: string) => import("document-model").SchemaPruneAction;
@@ -235,6 +241,9 @@ export declare const defineCommand: <TInput extends z.ZodType, TOutput = unknown
         setName: (name: string | {
             name: string;
         }) => import("document-model").SetNameAction;
+        setPreferredEditor: (input: string | null | {
+            preferredEditor: string | null;
+        }) => import("document-model").SetPreferredEditorAction;
         undo: (count?: number, scope?: string) => import("document-model").UndoAction;
         redo: (count?: number, scope?: string) => import("document-model").RedoAction;
         prune: (start?: number, end?: number, scope?: string) => import("document-model").SchemaPruneAction;
@@ -308,6 +317,9 @@ export declare const defineCommand: <TInput extends z.ZodType, TOutput = unknown
         setName: (name: string | {
             name: string;
         }) => import("document-model").SetNameAction;
+        setPreferredEditor: (input: string | null | {
+            preferredEditor: string | null;
+        }) => import("document-model").SetPreferredEditorAction;
         undo: (count?: number, scope?: string) => import("document-model").UndoAction;
         redo: (count?: number, scope?: string) => import("document-model").RedoAction;
         prune: (start?: number, end?: number, scope?: string) => import("document-model").SchemaPruneAction;
@@ -390,6 +402,9 @@ export declare const defineCommand: <TInput extends z.ZodType, TOutput = unknown
         setName: (name: string | {
             name: string;
         }) => import("document-model").SetNameAction;
+        setPreferredEditor: (input: string | null | {
+            preferredEditor: string | null;
+        }) => import("document-model").SetPreferredEditorAction;
         undo: (count?: number, scope?: string) => import("document-model").UndoAction;
         redo: (count?: number, scope?: string) => import("document-model").RedoAction;
         prune: (start?: number, end?: number, scope?: string) => import("document-model").SchemaPruneAction;
@@ -468,6 +483,9 @@ export declare const defineCommand: <TInput extends z.ZodType, TOutput = unknown
         setName: (name: string | {
             name: string;
         }) => import("document-model").SetNameAction;
+        setPreferredEditor: (input: string | null | {
+            preferredEditor: string | null;
+        }) => import("document-model").SetPreferredEditorAction;
         undo: (count?: number, scope?: string) => import("document-model").UndoAction;
         redo: (count?: number, scope?: string) => import("document-model").RedoAction;
         prune: (start?: number, end?: number, scope?: string) => import("document-model").SchemaPruneAction;

package/dist/framework.gen.d.ts

@@ -60,6 +60,9 @@ export declare const registry: import("@powerhousedao/ph-clint").InferRegistry<r
         setName: (name: string | {
             name: string;
         }) => import("document-model").SetNameAction;
+        setPreferredEditor: (input: string | null | {
+            preferredEditor: string | null;
+        }) => import("document-model").SetPreferredEditorAction;
         undo: (count?: number, scope?: string) => import("document-model").UndoAction;
         redo: (count?: number, scope?: string) => import("document-model").RedoAction;
         prune: (start?: number, end?: number, scope?: string) => import("document-model").SchemaPruneAction;

package/dist/skills/sync.d.ts

@@ -1 +1,40 @@
-export { type ManifestEntry, type SkillsManifest, type SyncResult, type SyncOptions, readManifest, diffSkills, syncExternalSkills, } from '@powerhousedao/ph-clint-dev/skills/sync';
+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>;

package/dist/skills/sync.js

@@ -1 +1,119 @@
-export { readManifest, diffSkills, syncExternalSkills, } from '@powerhousedao/ph-clint-dev/skills/sync';
+/**
+ * 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;
+}

package/dist/triggers/publish-trigger.d.ts

@@ -65,6 +65,9 @@ export declare const publishTrigger: import("@powerhousedao/ph-clint").Trigger<{
         setName: (name: string | {
             name: string;
         }) => import("document-model").SetNameAction;
+        setPreferredEditor: (input: string | null | {
+            preferredEditor: string | null;
+        }) => import("document-model").SetPreferredEditorAction;
         undo: (count?: number, scope?: string) => import("document-model").UndoAction;
         redo: (count?: number, scope?: string) => import("document-model").RedoAction;
         prune: (start?: number, end?: number, scope?: string) => import("document-model").SchemaPruneAction;

package/dist/triggers/spec-change.d.ts

@@ -69,6 +69,9 @@ export declare const specChangeTrigger: import("@powerhousedao/ph-clint").Trigge
         setName: (name: string | {
             name: string;
         }) => import("document-model").SetNameAction;
+        setPreferredEditor: (input: string | null | {
+            preferredEditor: string | null;
+        }) => import("document-model").SetPreferredEditorAction;
         undo: (count?: number, scope?: string) => import("document-model").UndoAction;
         redo: (count?: number, scope?: string) => import("document-model").RedoAction;
         prune: (start?: number, end?: number, scope?: string) => import("document-model").SchemaPruneAction;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powerhousedao/ph-clint-cli",
-  "version": "0.1.0-dev.75",
+  "version": "0.1.0-dev.77",
   "publishConfig": {
     "access": "public"
   },
@@ -27,15 +27,15 @@
   "dependencies": {
     "@electric-sql/pglite": "0.3.15",
     "@mastra/core": "^1.22.0",
-    "@mastra/libsql": "^1.7.4",
+    "@mastra/libsql": ">=1.7.4 <1.11.0",
     "@mastra/memory": "^1.13.1",
-    "@powerhousedao/ph-clint": "^0.1.0-dev.75",
-    "@powerhousedao/ph-clint-app": "^0.1.0-dev.75",
-    "@powerhousedao/ph-clint-dev": "^0.1.0-dev.75",
-    "@powerhousedao/reactor": "6.0.0-dev.216",
-    "@powerhousedao/reactor-api": "6.0.0-dev.216",
-    "@powerhousedao/shared": "6.0.0-dev.216",
-    "document-model": "6.0.0-dev.216",
+    "@powerhousedao/ph-clint": "^0.1.0-dev.77",
+    "@powerhousedao/ph-clint-app": "^0.1.0-dev.77",
+    "@powerhousedao/ph-clint-dev": "^0.1.0-dev.77",
+    "@powerhousedao/reactor": "6.0.0-dev.257",
+    "@powerhousedao/reactor-api": "6.0.0-dev.257",
+    "@powerhousedao/shared": "6.0.0-dev.257",
+    "document-model": "6.0.0-dev.257",
     "kysely": "^0.27.0",
     "kysely-pglite-dialect": "^1.3.0",
     "zod": "^4.3.6"

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

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

@@ -1,32 +0,0 @@
-/**
- * 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/commands/init.d.ts

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

package/dist/commands/init.js

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

package/dist/commands/regen.d.ts

@@ -1,18 +0,0 @@
-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>>;