@powerhousedao/ph-clint-cli 0.1.0-dev.94 → 0.1.0-dev.96

package/dist/codegen/scaffold.js

@@ -1,150 +0,0 @@
-/**
- * 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: [] };
-}

package/dist/codegen/write.d.ts

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

package/dist/codegen/write.js

@@ -1,32 +0,0 @@
-/**
- * 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));
-}

package/dist/skills/sync.d.ts

@@ -1,40 +0,0 @@
-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,119 +0,0 @@
-/**
- * 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;
-}