@powerhousedao/ph-clint-cli 0.1.0-dev.0

package/README.md

@@ -0,0 +1,84 @@
+# ph-clint-tpl-cli
+
+Template for the **ph-clint CLI side** of an implementation project. Starts
+as a flat layout (no Powerhouse reactor-package alongside it). When the
+`powerhouse` feature gets toggled on, the generator performs a one-time
+migration that moves this tree into `{name}-cli/` and scaffolds a sibling
+`{name}-app/`.
+
+## Folder layout
+
+```
+cli/
+├── src/
+│   ├── main.ts          # bin entrypoint (cli.run(process.argv))
+│   ├── cli.ts           # defineCli(...) call with @clint markers
+│   ├── config.ts        # configSchema + secretsSchema
+│   ├── mastra/          # Mastra Studio entry (populated when Mastra is on)
+│   ├── agents/          # Mastra agent definitions
+│   ├── commands/        # defineCommand(...) definitions
+│   ├── services/        # defineService(...) definitions
+│   └── triggers/        # defineTrigger(...) definitions
+├── prompts/             # Handlebars source for agent profiles & skills
+│   ├── agent-profiles/  # AgentBase.md + specialized profiles
+│   ├── skills-tpl/      # skill templates (authored here)
+│   └── skills-ext/      # external/pre-built skills (dropped in as-is)
+├── scripts/
+│   └── build-skills.ts  # compiles prompts/ → gen/ via ph-clint-dev
+├── gen/                 # codegen output (gitignored; built at build:skills)
+└── tests/               # user-authored tests
+```
+
+## Feature toggles
+
+Three independently togglable features. Each one is a `@clint:begin {name}`
+/ `@clint:end {name}` region that `ts-morph` can rewrite:
+
+### `powerhouse`
+
+Enables the Powerhouse Reactor stack (Reactor, optional Switchboard,
+optional Connect). On first enablement, the generator performs a one-time
+migration:
+
+1. Moves every file from `{root}/` to `{root}/{name}-cli/`.
+2. Runs `ph init` inside `{root}/{name}-app/` to scaffold the standard
+   Powerhouse reactor-package layout.
+3. Writes a new root `package.json` with passthrough scripts (no pnpm
+   workspaces — they interfere with `{name}-app`'s own builds).
+
+### `mastra`
+
+Enables the Mastra AI agent stack — agent definitions, thread-based memory
+(LibSQL), optional MCP client, and the Mastra Studio entry point at
+`src/mastra/index.ts` so `mastra dev` / `mastra build` / `mastra start` work.
+
+### `routine`
+
+Enables the tick-based routine loop and trigger registration. Forced on
+when `mastra` is enabled (an agent without a routine can still run from the
+REPL, but most useful setups want the loop).
+
+## Codegen markers
+
+Regions the generator can rewrite look like:
+
+```ts
+// src/cli.ts
+export const cli = defineCli({
+  // @clint:begin commands
+  commands: [/* list injected by codegen */],
+  // @clint:end commands
+
+  // @clint:begin services
+  services: [/* list injected by codegen */],
+  // @clint:end services
+});
+```
+
+Everything *outside* the markers is user-editable and preserved across
+regenerations. Everything *inside* a `@clint:begin`/`@clint:end` pair is
+codegen-owned.
+
+Files under `gen/` are fully codegen-owned — wiped and rewritten on every
+`build:skills`. Everything in `src/` is human-owned except for the
+explicitly marked regions.

package/dist/agents/clint-agent.d.ts

@@ -0,0 +1,12 @@
+import type { AgentProvider, AgentSetupContext } from '@powerhousedao/ph-clint';
+import type { Config } from '../framework.js';
+export declare const AGENT_ID = "clint";
+/**
+ * Agent factory for the ph-clint CLI.
+ *
+ * Demo mode echoes prompts; with an API key set via PH_CLINT_API_KEY, builds
+ * a full Mastra agent. The Powerhouse integration is still in scope but the
+ * agent does not yet write to any document model (document models land in
+ * Phase 4).
+ */
+export declare function createAgent(ctx: AgentSetupContext<Config>): Promise<AgentProvider>;

package/dist/agents/clint-agent.js

@@ -0,0 +1,42 @@
+export const AGENT_ID = 'clint';
+const instructions = `You are Clint — a ph-clint assistant that helps users scaffold, configure, and maintain ph-clint implementation projects.
+
+## Behavior
+- Be concise and practical.
+- When the user asks about a project, inspect the ClintProjectSpecification document via the Powerhouse Reactor when available.
+- Prefer small, incremental changes to the project's spec document over direct file edits.`;
+/**
+ * Agent factory for the ph-clint CLI.
+ *
+ * Demo mode echoes prompts; with an API key set via PH_CLINT_API_KEY, builds
+ * a full Mastra agent. The Powerhouse integration is still in scope but the
+ * agent does not yet write to any document model (document models land in
+ * Phase 4).
+ */
+export async function createAgent(ctx) {
+    if (!ctx.config.apiKey)
+        return createDemoAgent();
+    const { createMastraHelpers } = await import('@powerhousedao/ph-clint/mastra');
+    const { Agent } = await import('@mastra/core/agent');
+    const m = createMastraHelpers(ctx);
+    const mastraAgent = new Agent({
+        id: AGENT_ID,
+        name: 'Clint',
+        instructions,
+        model: { id: ctx.config.model, apiKey: ctx.config.apiKey },
+        tools: await m.getTools(),
+        memory: await m.createMemory(),
+    });
+    return m.wrapAgent(mastraAgent, { maxSteps: 40 });
+}
+function createDemoAgent() {
+    return {
+        id: AGENT_ID,
+        async *stream(prompt) {
+            yield {
+                type: 'text-delta',
+                text: `[Clint demo mode — set PH_CLINT_API_KEY for real LLM responses]\n\nYou said: "${prompt}"\n`,
+            };
+        },
+    };
+}

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export declare const cli: import("@powerhousedao/ph-clint").Cli;

package/dist/cli.js

@@ -0,0 +1,79 @@
+/**
+ * ph-clint CLI definition.
+ *
+ * This file is the codegen anchor point. Regions bracketed by
+ * `@clint:begin {name}` / `@clint:end {name}` comment markers are
+ * rewritten by ph-clint-cli's generator when the project spec changes.
+ * Everything outside the markers is user-editable and preserved.
+ */
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { defineCli, buildDefaultReactor } from '@powerhousedao/ph-clint';
+import { CLI_NAME, CLI_VERSION } from './config.js';
+import { configSchema, secretsSchema } from './framework.js';
+// @clint:begin imports
+import { documentModels } from '@powerhousedao/ph-clint-app';
+import { createAgent } from './agents/clint-agent.js';
+import { init } from './commands/init.js';
+import { regen } from './commands/regen.js';
+import { specChangeTrigger } from './triggers/spec-change.js';
+// @clint:end imports
+// Connect (ph connect) must run inside the Reactor Package (ph-clint-app).
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const appDir = path.resolve(__dirname, '../../ph-clint-app');
+export const cli = defineCli({
+    name: CLI_NAME,
+    version: CLI_VERSION,
+    description: `${CLI_NAME} v${CLI_VERSION} — scaffold and maintain ph-clint implementation projects`,
+    configSchema,
+    secretsSchema,
+    // @clint:begin commands
+    commands: [init, regen],
+    // @clint:end commands
+    // @clint:begin services
+    services: [],
+    // @clint:end services
+    // @clint:begin triggers
+    triggers: [specChangeTrigger],
+    // @clint:end triggers
+    // @clint:begin prompts
+    prompts: {
+        sources: [],
+        agents: {},
+        skills: {},
+    },
+    // @clint:end prompts
+    // @clint:begin events
+    events: {},
+    // @clint:end events
+    // @clint:begin interactive
+    interactive: {
+        welcome: ({ config, workdir }) => {
+            const mode = config.apiKey
+                ? config.model
+                : 'demo mode — set PH_CLINT_API_KEY for real LLM responses';
+            return [
+                `ph-clint v${CLI_VERSION}`,
+                `Model:   ${mode}`,
+                `Workdir: ${workdir}`,
+                '',
+                'Type a message to talk to the agent, or /help for commands.',
+            ].join('\n');
+        },
+    },
+    // @clint:end interactive
+});
+// @clint:begin reactor
+cli.configureReactor({
+    create: (ctx) => buildDefaultReactor(ctx, {
+        documentModels,
+        drive: { name: 'Clint' },
+        subscriptions: { documentTypes: ['powerhouse/ph-clint-project'] },
+    }),
+    switchboard: { enabled: true },
+    connect: { enabled: true, workdir: appDir },
+});
+// @clint:end reactor
+// @clint:begin mastra
+cli.configureAgent(createAgent);
+// @clint:end mastra

package/dist/codegen/builders/agent-base-md.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Builds `prompts/agent-profiles/AgentBase.md` — the minimal base profile.
+ */
+import { type ClintProjectSpec } from '../../spec/types.js';
+export declare function buildAgentBaseMd(spec: ClintProjectSpec): string;

package/dist/codegen/builders/agent-base-md.js

@@ -0,0 +1,18 @@
+/**
+ * Builds `prompts/agent-profiles/AgentBase.md` — the minimal base profile.
+ */
+import { getPackageName, } from '../../spec/types.js';
+export function buildAgentBaseMd(spec) {
+    return [
+        '# Agent Base System Prompt',
+        '',
+        `You are {{agentName}}, an agent available through the ${getPackageName(spec)} CLI.`,
+        '',
+        '## Capabilities',
+        '',
+        'This base profile is a minimal placeholder. Extend it with project-specific',
+        "context, workflows, and domain knowledge. Additional sections listed in the",
+        "agent's `sections` array are concatenated after this file at build time.",
+        '',
+    ].join('\n');
+}

package/dist/codegen/builders/agent-ts.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Builds `src/agents/agent.ts` — a minimal Mastra agent factory.
+ *
+ * Emitted only when `features.mastra.enabled`. The generated agent falls back
+ * to a deterministic echo-style demo provider when no API key is configured,
+ * so `pnpm dev` works immediately out of the box.
+ */
+import { type ClintProjectSpec } from '../../spec/types.js';
+export declare function buildAgentTs(spec: ClintProjectSpec): string;

package/dist/codegen/builders/agent-ts.js

@@ -0,0 +1,34 @@
+export function buildAgentTs(spec) {
+    const id = spec.name;
+    return [
+        "import type { AgentProvider, AgentSetupContext, StreamChunk } from '@powerhousedao/ph-clint';",
+        "import type { Config } from '../framework.js';",
+        '',
+        '/**',
+        ' * Demo agent — deterministic echo responses. Replace with a real Mastra',
+        " * `Agent` once you've wired your model + tools.",
+        ' */',
+        'function createDemoAgent(): AgentProvider {',
+        '  return {',
+        `    id: '${id}',`,
+        '    async *stream(prompt) {',
+        '      yield {',
+        "        type: 'text-delta',",
+        "        text: `You said: ${prompt}\\n(demo mode — set an API key and replace createDemoAgent with a Mastra Agent)`,",
+        '      } satisfies StreamChunk;',
+        '    },',
+        '  };',
+        '}',
+        '',
+        '/**',
+        ' * Agent factory invoked by `cli.configureAgent`. Receives the resolved',
+        ' * config and workdir; return an AgentProvider.',
+        ' */',
+        'export async function createAgent(',
+        '  _ctx: AgentSetupContext<Config>,',
+        '): Promise<AgentProvider> {',
+        '  return createDemoAgent();',
+        '}',
+        '',
+    ].join('\n');
+}

package/dist/codegen/builders/app-index-ts.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Builds `{name}-app/index.ts` — the top-level re-export barrel for the
+ * reactor package. Impl code imports from `'{name}-app'` instead of drilling
+ * into `'{name}-app/document-models/<slug>/v1/gen/...'`.
+ *
+ * Each entry re-exports a document-model subfolder's `index.ts`, which in
+ * turn re-exports the module object (`PhClintProject`, ...), action creators,
+ * document/state types, and type guards. Fully machine-owned: regen on every
+ * run.
+ *
+ * Powerhouse's own codegen might emit its own `index.ts` (as is the case for
+ * ph-clint-app today, which has manifest/editors/processors re-exports). When
+ * that exists, leave it alone — users hand-merge. Our codegen only emits when
+ * the file is absent or was emitted by a previous ph-clint-cli run (hash
+ * matches the ledger).
+ */
+import { type ClintProjectSpec } from '../../spec/types.js';
+export declare function buildAppIndexTs(spec: ClintProjectSpec): string | null;

package/dist/codegen/builders/app-index-ts.js

@@ -0,0 +1,33 @@
+/**
+ * Builds `{name}-app/index.ts` — the top-level re-export barrel for the
+ * reactor package. Impl code imports from `'{name}-app'` instead of drilling
+ * into `'{name}-app/document-models/<slug>/v1/gen/...'`.
+ *
+ * Each entry re-exports a document-model subfolder's `index.ts`, which in
+ * turn re-exports the module object (`PhClintProject`, ...), action creators,
+ * document/state types, and type guards. Fully machine-owned: regen on every
+ * run.
+ *
+ * Powerhouse's own codegen might emit its own `index.ts` (as is the case for
+ * ph-clint-app today, which has manifest/editors/processors re-exports). When
+ * that exists, leave it alone — users hand-merge. Our codegen only emits when
+ * the file is absent or was emitted by a previous ph-clint-cli run (hash
+ * matches the ledger).
+ */
+import { getDocumentTypeSlug, } from '../../spec/types.js';
+export function buildAppIndexTs(spec) {
+    if (!spec.features.powerhouse.enabled)
+        return null;
+    if (spec.documentTypes.length === 0)
+        return null;
+    const lines = [];
+    lines.push('// THIS FILE IS GENERATED BY ph-clint-cli.');
+    lines.push('// Re-exports every registered document model from a single top-level');
+    lines.push('// entry so impl code can `import { ... } from \'{name}-app\'`.');
+    lines.push('');
+    for (const docType of spec.documentTypes) {
+        const slug = getDocumentTypeSlug(docType);
+        lines.push(`export * from './document-models/${slug}/index.js';`);
+    }
+    return lines.join('\n') + '\n';
+}

package/dist/codegen/builders/build-skills-ts.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Builds `scripts/build-skills.ts` — the build-time skill compiler.
+ */
+export declare function buildBuildSkillsScript(): string;

package/dist/codegen/builders/build-skills-ts.js

@@ -0,0 +1,37 @@
+/**
+ * Builds `scripts/build-skills.ts` — the build-time skill compiler.
+ */
+export function buildBuildSkillsScript() {
+    return [
+        '#!/usr/bin/env tsx',
+        '/**',
+        ' * Build script — compiles Handlebars templates in `prompts/` into static',
+        ' * SKILL.md files and agent instruction strings under `gen/`, using',
+        " * ph-clint-dev's `buildSkills`.",
+        ' */',
+        "import path from 'node:path';",
+        "import { buildSkills } from '@powerhousedao/ph-clint-dev';",
+        "import { cli } from '../src/cli.js';",
+        '',
+        'const PROJECT_ROOT = path.resolve(import.meta.dirname, \'..\');',
+        '',
+        '// @clint:begin templateVars',
+        'function loadTemplateVars(): Record<string, string> {',
+        '  return {',
+        "    agentName: '{{AGENT_NAME}}',",
+        '  };',
+        '}',
+        '// @clint:end templateVars',
+        '',
+        'buildSkills({',
+        "  include: [path.join(PROJECT_ROOT, 'prompts')],",
+        '  context: loadTemplateVars(),',
+        '  output: [',
+        "    path.join(PROJECT_ROOT, 'gen'),",
+        "    path.join(PROJECT_ROOT, 'dist', 'gen'),",
+        '  ],',
+        '  cli,',
+        '});',
+        '',
+    ].join('\n');
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Builds the CLI-side `package.json` (the ph-clint CLI itself).
+ *
+ * When `features.powerhouse.enabled`, this file lives at
+ * `{root}/{name}-cli/package.json`. Otherwise at `{root}/package.json`.
+ */
+import { type ClintProjectSpec } from '../../spec/types.js';
+export declare function buildCliPackageJson(spec: ClintProjectSpec): string;

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

@@ -0,0 +1,69 @@
+/**
+ * Builds the CLI-side `package.json` (the ph-clint CLI itself).
+ *
+ * When `features.powerhouse.enabled`, this file lives at
+ * `{root}/{name}-cli/package.json`. Otherwise at `{root}/package.json`.
+ */
+import { getBinName, getPackageName, } from '../../spec/types.js';
+/** Pinned version range for peer ph-clint packages emitted into generated projects. */
+const PH_CLINT_VERSION = '^0.1.0';
+const POWERHOUSE_VERSION = '6.0.0-dev.170';
+export function buildCliPackageJson(spec) {
+    const { mastra, powerhouse } = spec.features;
+    const pkgName = powerhouse.enabled
+        ? `${getPackageName(spec)}-cli`
+        : getPackageName(spec);
+    const bin = getBinName(spec);
+    const dependencies = {
+        'ph-clint': PH_CLINT_VERSION,
+        zod: '^4.3.6',
+    };
+    if (mastra.enabled) {
+        dependencies['@mastra/core'] = '^1.22.0';
+        dependencies['@mastra/libsql'] = '^1.7.4';
+        dependencies['@mastra/memory'] = '^1.13.1';
+    }
+    if (powerhouse.enabled) {
+        dependencies[`${spec.name}-app`] = `file:../${spec.name}-app`;
+        dependencies['@powerhousedao/reactor'] = POWERHOUSE_VERSION;
+        dependencies['@powerhousedao/reactor-api'] = POWERHOUSE_VERSION;
+        dependencies['@powerhousedao/shared'] = POWERHOUSE_VERSION;
+        dependencies['document-model'] = POWERHOUSE_VERSION;
+    }
+    const scripts = {
+        'build:skills': 'tsx scripts/build-skills.ts',
+        build: 'pnpm build:skills && tsc',
+        dev: 'tsx src/main.ts',
+        start: 'node dist/main.js',
+        test: "NODE_OPTIONS='--experimental-vm-modules' jest --detectOpenHandles",
+        lint: 'eslint src',
+    };
+    if (mastra.enabled) {
+        scripts['mastra:dev'] = 'mastra dev';
+        scripts['mastra:build'] = 'mastra build';
+        scripts['mastra:start'] = 'mastra start';
+    }
+    scripts['publish:npm'] = 'pnpm build && pnpm publish --no-git-checks';
+    const pkg = {
+        name: pkgName,
+        version: spec.version,
+        private: true,
+        type: 'module',
+    };
+    if (spec.description)
+        pkg.description = spec.description;
+    pkg.bin = { [bin]: './dist/main.js' };
+    pkg.scripts = scripts;
+    pkg.dependencies = dependencies;
+    pkg.devDependencies = {
+        '@jest/globals': '^30.2.0',
+        '@types/node': '^25.5.2',
+        jest: '^30.2.0',
+        'ph-clint-dev': PH_CLINT_VERSION,
+        'ts-jest': '^29.4.6',
+        tsx: '^4.19.0',
+        typescript: '^6.0.2',
+    };
+    pkg.engines = { node: '>=22.13.0' };
+    return JSON.stringify(pkg, null, 2) + '\n';
+}

package/dist/codegen/builders/cli-ts.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Builds `src/cli.ts` — the defineCli() call with feature blocks guarded by
+ * `@clint:begin`/`@clint:end` markers so the code generator can patch
+ * specific regions on subsequent runs (delta mode — future phase).
+ */
+import { type ClintProjectSpec } from '../../spec/types.js';
+export declare function buildCliTs(spec: ClintProjectSpec): string;

package/dist/codegen/builders/cli-ts.js

@@ -0,0 +1,110 @@
+export function buildCliTs(spec) {
+    const { mastra, routine, powerhouse } = spec.features;
+    const lines = [];
+    lines.push('/**');
+    lines.push(' * CLI definition.');
+    lines.push(' *');
+    lines.push(' * Generated by ph-clint. Regions bracketed by @clint:begin/@clint:end');
+    lines.push(' * markers are rewritten by ph-clint when the project spec changes.');
+    lines.push(' * Everything outside the markers is user-editable and preserved.');
+    lines.push(' */');
+    if (powerhouse.enabled) {
+        lines.push(`import path from 'node:path';`);
+        lines.push(`import { fileURLToPath } from 'node:url';`);
+        lines.push(`import { defineCli, buildDefaultReactor } from '@powerhousedao/ph-clint';`);
+    }
+    else {
+        lines.push(`import { defineCli } from '@powerhousedao/ph-clint';`);
+    }
+    lines.push(`import { CLI_NAME, CLI_VERSION } from './config.js';`);
+    lines.push(`import { configSchema, secretsSchema } from './framework.js';`);
+    lines.push('');
+    lines.push('// @clint:begin imports');
+    if (powerhouse.enabled) {
+        lines.push(`import { documentModels } from '${spec.name}-app';`);
+    }
+    if (mastra.enabled) {
+        lines.push(`import { createAgent } from './agents/agent.js';`);
+    }
+    lines.push('// @clint:end imports');
+    lines.push('');
+    if (powerhouse.enabled) {
+        lines.push(`const __dirname = path.dirname(fileURLToPath(import.meta.url));`);
+        lines.push(`const appDir = path.resolve(__dirname, '../../${spec.name}-app');`);
+        lines.push('');
+    }
+    lines.push('export const cli = defineCli({');
+    lines.push('  name: CLI_NAME,');
+    lines.push('  version: CLI_VERSION,');
+    lines.push('  description: `${CLI_NAME} v${CLI_VERSION}`,');
+    lines.push('  configSchema,');
+    lines.push('  secretsSchema,');
+    lines.push('');
+    lines.push('  // @clint:begin commands');
+    lines.push('  commands: [],');
+    lines.push('  // @clint:end commands');
+    lines.push('');
+    lines.push('  // @clint:begin services');
+    lines.push('  services: [],');
+    lines.push('  // @clint:end services');
+    lines.push('');
+    lines.push('  // @clint:begin triggers');
+    if (routine.enabled) {
+        lines.push('  triggers: [],');
+    }
+    else {
+        lines.push('  triggers: [],');
+    }
+    lines.push('  // @clint:end triggers');
+    lines.push('');
+    lines.push('  // @clint:begin prompts');
+    lines.push('  prompts: {');
+    lines.push('    sources: [],');
+    lines.push('    agents: {},');
+    lines.push('    skills: {},');
+    lines.push('  },');
+    lines.push('  // @clint:end prompts');
+    lines.push('');
+    lines.push('  // @clint:begin events');
+    lines.push('  events: {},');
+    lines.push('  // @clint:end events');
+    lines.push('');
+    lines.push('  // @clint:begin interactive');
+    lines.push('  interactive: {');
+    lines.push(`    welcome: ({ workdir }) =>`);
+    lines.push('      [');
+    lines.push('        `${CLI_NAME} v${CLI_VERSION}`,');
+    lines.push('        `Workdir: ${workdir}`,');
+    lines.push("        '',");
+    if (mastra.enabled) {
+        lines.push("        'Type a message to talk to the agent, or /help for commands.',");
+    }
+    else {
+        lines.push("        'Type /help for commands.',");
+    }
+    lines.push("      ].join('\\n'),");
+    lines.push('  },');
+    lines.push('  // @clint:end interactive');
+    lines.push('});');
+    lines.push('');
+    lines.push('// @clint:begin reactor');
+    if (powerhouse.enabled) {
+        lines.push('cli.configureReactor({');
+        lines.push('  create: (ctx) =>');
+        lines.push('    buildDefaultReactor(ctx, {');
+        lines.push('      documentModels,');
+        lines.push(`      drive: { name: '${spec.name}' },`);
+        lines.push('    }),');
+        lines.push(`  switchboard: { enabled: ${String(powerhouse.switchboard)} },`);
+        lines.push(`  connect: { enabled: ${String(powerhouse.connect)}, workdir: appDir },`);
+        lines.push('});');
+    }
+    lines.push('// @clint:end reactor');
+    lines.push('');
+    lines.push('// @clint:begin mastra');
+    if (mastra.enabled) {
+        lines.push('cli.configureAgent(createAgent);');
+    }
+    lines.push('// @clint:end mastra');
+    return lines.join('\n') + '\n';
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Builds `src/config.ts` — CLI identity constants (name, version, project
+ * root path). The Zod `configSchema` / `secretsSchema` are emitted by
+ * `buildFrameworkTs` into `src/framework.ts` (user-owned, init-only) so users
+ * can extend them without fighting the generator.
+ */
+import { type ClintProjectSpec } from '../../spec/types.js';
+export declare function buildConfigTs(spec: ClintProjectSpec): string;

package/dist/codegen/builders/config-ts.js

@@ -0,0 +1,21 @@
+/**
+ * Builds `src/config.ts` — CLI identity constants (name, version, project
+ * root path). The Zod `configSchema` / `secretsSchema` are emitted by
+ * `buildFrameworkTs` into `src/framework.ts` (user-owned, init-only) so users
+ * can extend them without fighting the generator.
+ */
+import { getBinName, } from '../../spec/types.js';
+export function buildConfigTs(spec) {
+    const cliName = getBinName(spec);
+    const lines = [];
+    lines.push(`import path from 'node:path';`);
+    lines.push(`import { fileURLToPath } from 'node:url';`);
+    lines.push('');
+    lines.push('/** CLI name — used for config resolution, env var prefixing, and .ph/ paths. */');
+    lines.push(`export const CLI_NAME = '${cliName}';`);
+    lines.push(`export const CLI_VERSION = '${spec.version}';`);
+    lines.push('');
+    lines.push('/** Project root — resolved from this file location. */');
+    lines.push('export const PROJECT_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), \'..\');');
+    return lines.join('\n') + '\n';
+}

package/dist/codegen/builders/eslint-config-js.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Builds `eslint.config.js` for the CLI — placeholder flat config.
+ */
+export declare function buildEslintConfigJs(): string;

package/dist/codegen/builders/eslint-config-js.js

@@ -0,0 +1,13 @@
+/**
+ * Builds `eslint.config.js` for the CLI — placeholder flat config.
+ */
+export function buildEslintConfigJs() {
+    return [
+        '// @clint:begin eslint',
+        '// Placeholder ESLint flat config — replaced by codegen when the',
+        "// project's lint stack is configured.",
+        'export default [];',
+        '// @clint:end eslint',
+        '',
+    ].join('\n');
+}