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

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

@@ -1,44 +0,0 @@
-/**
- * Builds the project README for a freshly-generated ph-clint project.
- */
-import { getPackageName, } from '../../spec/types.js';
-export function buildReadme(spec) {
-    const { mastra, routine, powerhouse } = spec.features;
-    const title = getPackageName(spec);
-    const lines = [];
-    lines.push(`# ${title}`);
-    lines.push('');
-    lines.push(spec.description || 'A ph-clint-based project.');
-    lines.push('');
-    lines.push('## Getting started');
-    lines.push('');
-    lines.push('```sh');
-    lines.push('pnpm install');
-    lines.push('pnpm dev');
-    lines.push('```');
-    lines.push('');
-    lines.push('## Enabled features');
-    lines.push('');
-    lines.push(`- **Powerhouse**: ${powerhouse.enabled ? 'on' : 'off'}`);
-    if (powerhouse.enabled) {
-        lines.push(`  - Switchboard: ${powerhouse.switchboard ? 'on' : 'off'}`);
-        lines.push(`  - Connect: ${powerhouse.connect ? 'on' : 'off'}`);
-    }
-    lines.push(`- **Mastra agent**: ${mastra.enabled ? 'on' : 'off'}`);
-    lines.push(`- **Routine loop**: ${routine.enabled ? 'on' : 'off'}`);
-    lines.push('');
-    lines.push('## Regenerate');
-    lines.push('');
-    lines.push('Toggle features or update metadata in `.ph/ph-clint-cli/project-spec.json`,');
-    lines.push('then re-run `ph-clint clint-project-regen` to regenerate.');
-    lines.push('');
-    if (powerhouse.enabled) {
-        lines.push('## Split layout');
-        lines.push('');
-        lines.push(`This project is split into \`${spec.name}-cli/\` (the CLI) and \`${spec.name}-app/\` (the Powerhouse reactor package).`);
-        lines.push('');
-        lines.push(`Run \`ph init\` inside \`${spec.name}-app/\` to scaffold the reactor package layout (document-models, editors, manifest, etc.).`);
-        lines.push('');
-    }
-    return lines.join('\n');
-}

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

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

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

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

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

@@ -1,4 +0,0 @@
-/**
- * Builds `tsconfig.json` for the CLI.
- */
-export declare function buildTsconfigJson(): string;

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

@@ -1,22 +0,0 @@
-/**
- * Builds `tsconfig.json` for the CLI.
- */
-export function buildTsconfigJson() {
-    const tsconfig = {
-        compilerOptions: {
-            target: 'ES2022',
-            module: 'Node16',
-            moduleResolution: 'Node16',
-            outDir: 'dist',
-            rootDir: 'src',
-            strict: true,
-            isolatedModules: true,
-            esModuleInterop: true,
-            skipLibCheck: true,
-            declaration: true,
-            types: ['node'],
-        },
-        include: ['src'],
-    };
-    return JSON.stringify(tsconfig, null, 2) + '\n';
-}

package/dist/codegen/exec.d.ts

@@ -1,20 +0,0 @@
-export interface RunCommandOptions {
-    cwd: string;
-    /** Override stdio; default `'inherit'`. Pass `'ignore'` for tests. */
-    stdio?: 'inherit' | 'ignore';
-    /** Extra env vars (merged with process.env). */
-    env?: Record<string, string>;
-}
-export interface RunCommandResult {
-    command: string;
-    args: string[];
-    cwd: string;
-    exitCode: number;
-}
-/**
- * Run `command args` in `cwd`, forwarding stdio by default. Resolves to
- * the exit code. Does NOT throw on non-zero — callers decide how to react.
- */
-export declare function runCommand(command: string, args: string[], options: RunCommandOptions): Promise<RunCommandResult>;
-/** Returns true if `command` is on PATH. */
-export declare function hasCommandOnPath(command: string): Promise<boolean>;

package/dist/codegen/exec.js

@@ -1,41 +0,0 @@
-/**
- * Small helpers for invoking external commands during code generation.
- *
- * We deliberately keep this separate from `ph-clint`'s process manager:
- * here we need synchronous-feeling prompt-forwarding (stdio inherited) so
- * the user can respond to interactive prompts from `ph init` or from a
- * package manager.
- */
-import { spawn } from 'node:child_process';
-/**
- * Run `command args` in `cwd`, forwarding stdio by default. Resolves to
- * the exit code. Does NOT throw on non-zero — callers decide how to react.
- */
-export async function runCommand(command, args, options) {
-    return new Promise((resolve, reject) => {
-        const child = spawn(command, args, {
-            cwd: options.cwd,
-            stdio: options.stdio ?? 'inherit',
-            env: options.env ? { ...process.env, ...options.env } : process.env,
-        });
-        child.once('error', reject);
-        child.once('close', (code) => {
-            resolve({
-                command,
-                args,
-                cwd: options.cwd,
-                exitCode: code ?? 0,
-            });
-        });
-    });
-}
-/** 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));
-    });
-}

package/dist/codegen/hashes.d.ts

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

package/dist/codegen/hashes.js

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

package/dist/codegen/markers.d.ts

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

package/dist/codegen/markers.js

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

package/dist/codegen/migrate/flat-to-split.d.ts

@@ -1,15 +0,0 @@
-import { type ClintProjectSpec } from '../../spec/types.js';
-export interface FlatToSplitOptions {
-    targetDir: string;
-    spec: ClintProjectSpec;
-    /** Bypass the git-dirty guard. */
-    force?: boolean;
-    /** Optional warn sink for non-fatal messages. */
-    onWarn?: (msg: string) => void;
-}
-export interface FlatToSplitResult {
-    movedEntries: string[];
-    cliDir: string;
-    appDir: string;
-}
-export declare function migrateFlatToSplit(options: FlatToSplitOptions): Promise<FlatToSplitResult>;

package/dist/codegen/migrate/flat-to-split.js

@@ -1,119 +0,0 @@
-/**
- * One-shot migration that runs when a project's spec flips
- * `features.powerhouse.enabled` from `false` to `true`. It reshapes the
- * on-disk layout from flat (everything at the project root) to split
- * (`{name}-cli/` + `{name}-app/` siblings).
- *
- * The follow-up update-mode regeneration then fills in the correct content
- * for each file in its new location — so this migration only moves bytes
- * around. Content updates belong to the generator.
- *
- * `node_modules` is deliberately NOT moved — pnpm `file:` protocol uses
- * symlinks that do not survive a cross-directory rename cleanly. Callers
- * should re-run `pnpm install` after the migration.
- */
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { spawn } from 'node:child_process';
-import { getAppFolderName, getCliFolderName, } from '../../spec/types.js';
-import { readHashes, writeHashes } from '../hashes.js';
-/** Entries we never move during a flat → split migration. */
-function isUnmovable(entry, cliFolder, appFolder) {
-    if (entry === '.git')
-        return true;
-    if (entry === '.ph')
-        return true;
-    if (entry === 'README.md')
-        return true;
-    if (entry === 'node_modules')
-        return true;
-    if (entry === cliFolder)
-        return true;
-    if (entry === appFolder)
-        return true;
-    return false;
-}
-/**
- * Guard: if the target is a git repo with a dirty working tree, refuse to
- * migrate unless `force`. We never want to discard uncommitted edits.
- * Resolves to `null` when the dir is not a git repo.
- */
-async function gitDirty(dir) {
-    return new Promise((resolve) => {
-        const child = spawn('git', ['status', '--porcelain'], {
-            cwd: dir,
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-        let out = '';
-        child.stdout?.on('data', (d) => {
-            out += d.toString();
-        });
-        child.once('error', () => resolve(null));
-        child.once('close', (code) => {
-            if (code !== 0)
-                resolve(null);
-            else
-                resolve(out.trim() || null);
-        });
-    });
-}
-export async function migrateFlatToSplit(options) {
-    const { targetDir, spec } = options;
-    const cliFolder = getCliFolderName(spec);
-    const appFolder = getAppFolderName(spec);
-    const cliDir = path.join(targetDir, cliFolder);
-    const appDir = path.join(targetDir, appFolder);
-    if (!options.force) {
-        const dirty = await gitDirty(targetDir);
-        if (dirty) {
-            throw new Error(`refusing to migrate flat → split: ${targetDir} has uncommitted changes.\n` +
-                'Commit or stash first, or re-run with --force.');
-        }
-    }
-    // Create the CLI destination. If it already exists and is non-empty we
-    // treat that as a malformed state and bail — a previous migration probably
-    // got interrupted.
-    await fs.mkdir(cliDir, { recursive: true });
-    const cliExisting = await fs.readdir(cliDir);
-    if (cliExisting.length > 0) {
-        throw new Error(`cannot migrate: ${cliDir} already exists and is non-empty. ` +
-            'Resolve manually before re-running.');
-    }
-    const entries = await fs.readdir(targetDir);
-    const moved = [];
-    for (const entry of entries) {
-        if (isUnmovable(entry, cliFolder, appFolder)) {
-            if (entry === 'node_modules' && options.onWarn) {
-                options.onWarn('skipped node_modules during flat → split migration; re-run `pnpm install`.');
-            }
-            continue;
-        }
-        const src = path.join(targetDir, entry);
-        const dst = path.join(cliDir, entry);
-        await fs.rename(src, dst);
-        moved.push(entry);
-    }
-    // Rekey stored hashes so they still line up with the moved paths.
-    await rekeyHashes(targetDir, moved, cliFolder);
-    // Create the app folder with a placeholder so tooling (git, `ph init`) can
-    // find it. The generator and/or `ph init` fills in the real contents.
-    await fs.mkdir(appDir, { recursive: true });
-    return { movedEntries: moved, cliDir, appDir };
-}
-async function rekeyHashes(targetDir, movedEntries, cliFolder) {
-    const before = await readHashes(targetDir);
-    if (Object.keys(before).length === 0)
-        return;
-    const movedSet = new Set(movedEntries);
-    const after = {};
-    for (const [key, hash] of Object.entries(before)) {
-        const top = key.split(/[\\/]/)[0];
-        if (movedSet.has(top)) {
-            after[path.posix.join(cliFolder, key)] = hash;
-        }
-        else {
-            after[key] = hash;
-        }
-    }
-    await writeHashes(targetDir, after);
-}

package/dist/codegen/scaffold.d.ts

@@ -1,34 +0,0 @@
-import type { ClintProjectSpec } from '../spec/types.js';
-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;
-    /** Stdio passthrough (tests pass 'ignore'). */
-    stdio?: 'inherit' | 'ignore';
-}
-export interface PhInitResult {
-    ran: boolean;
-    exitCode?: number;
-    reason?: string;
-}
-export declare function runPhInit(options: PhInitOptions): Promise<PhInitResult>;
-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;
-    stdio?: 'inherit' | 'ignore';
-}
-export interface PnpmInstallResult {
-    ran: string[];
-    skipped: string[];
-    reason?: string;
-}
-export declare function runPnpmInstall(options: PnpmInstallOptions): Promise<PnpmInstallResult>;

package/dist/codegen/scaffold.js

@@ -1,60 +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 { hasCommandOnPath, runCommand } from './exec.js';
-export async function runPhInit(options) {
-    const log = options.log ?? (() => { });
-    const binName = options.binName ?? 'ph';
-    const appFolder = path.basename(options.appDir);
-    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' };
-    }
-    // `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 });
-    log(`Running \`${binName} init ${appFolder}\` in ${options.targetDir} …`);
-    const result = await runCommand(binName, [
-        'init',
-        appFolder,
-        '--pnpm',
-        '--dev',
-    ], { cwd: options.targetDir, stdio: options.stdio ?? 'inherit' });
-    if (result.exitCode !== 0) {
-        log(`\`${binName} init\` exited with code ${result.exitCode}. ` +
-            'You can re-run it manually after resolving the issue.');
-    }
-    return { ran: true, exitCode: result.exitCode };
-}
-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 runCommand(binName, ['install'], {
-            cwd: dir,
-            stdio: options.stdio ?? 'inherit',
-        });
-        if (result.exitCode !== 0) {
-            log(`\`${binName} install\` exited with code ${result.exitCode} in ${dir}. ` +
-                'Retry manually once the underlying issue is resolved.');
-            // Don't abort the whole chain — subsequent dirs may still work.
-        }
-        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));
-}