@powerhousedao/ph-clint-cli 0.1.0-dev.86 → 0.1.0-dev.87

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

@@ -0,0 +1,43 @@
+/**
+ * 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/...'`.
+ *
+ * Only re-exports document types belonging to the app package (the project's
+ * own reactor package). External packages' document types are imported from
+ * their own npm packages, not from the app barrel.
+ */
+import { getAppPackageName, getDocumentTypeSlug, isDocTypeGlob, phAtLeast, } from '../../spec/types.js';
+export function buildAppIndexTs(spec) {
+    if (!phAtLeast(spec.features.powerhouse, 'Reactor'))
+        return null;
+    const lines = [];
+    // Standard Powerhouse reactor-package barrel — matches what `ph init`
+    // generates. Required by main.tsx (Connect) and cli.ts imports.
+    lines.push('// THIS FILE IS GENERATED BY ph-clint-cli.');
+    lines.push("import type { Manifest } from 'document-model';");
+    lines.push("import manifestJson from './powerhouse.manifest.json' with { type: 'json' };");
+    lines.push("export { documentModels } from './document-models/document-models.js';");
+    lines.push("export { upgradeManifests } from './document-models/upgrade-manifests.js';");
+    lines.push("export { editors } from './editors/editors.js';");
+    lines.push("export { processorFactory } from './processors/factory.js';");
+    lines.push('export const manifest: Manifest = manifestJson;');
+    // Per-document-type re-exports so impl code can import from
+    // '{name}-app' instead of drilling into deep paths.
+    const appPkg = getAppPackageName(spec);
+    const appEntry = spec.packages.find((p) => p.packageName === appPkg);
+    const docTypes = appEntry?.documentTypes ?? [];
+    if (docTypes.length > 0) {
+        const hasGlobs = docTypes.some(isDocTypeGlob);
+        const explicits = docTypes.filter((dt) => !isDocTypeGlob(dt));
+        lines.push('');
+        if (hasGlobs) {
+            lines.push("export * from './document-models/index.js';");
+        }
+        for (const docType of explicits) {
+            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,128 @@
+/**
+ * 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 { getAppDirName, getAppPackageName, getBinName, getPackageName, phAtLeast, } from '../../spec/types.js';
+import { CLI_VERSION } from '../../config.js';
+import { getPhVersion } from '../scaffold.js';
+/**
+ * Derive a semver range from the running ph-clint-cli version that respects
+ * the dev / staging / production channel boundary. This is the version range
+ * emitted into *scaffolded* projects' package.json for @powerhousedao/ph-clint
+ * and @powerhousedao/ph-clint-dev dependencies.
+ *
+ * CLI_VERSION is the version of ph-clint-cli itself (read from its own
+ * package.json at startup). Since all framework packages share a lockstep
+ * version, this is also the correct base for the dependency range.
+ *
+ * Examples:
+ *   "0.1.0"            → "^0.1.0"            (production — stable only)
+ *   "0.1.0-staging.2"  → "^0.1.0-staging.0"  (staging + stable)
+ *   "0.1.0-dev.4"      → "^0.1.0-dev.0"      (dev + staging + stable)
+ *
+ * This works because semver orders prereleases alphabetically:
+ * dev.N < staging.N < release. A caret range starting at dev.0 naturally
+ * upgrades through staging to production.
+ */
+function phClintRange(version) {
+    const match = /^(\d+\.\d+\.\d+)(?:-([a-z]+)\.\d+)?/.exec(version);
+    if (!match)
+        return `^${version}`;
+    const base = match[1];
+    const channel = match[2]; // "dev", "staging", or undefined
+    // For prerelease channels, pin exact version. Caret ranges like ^0.1.0-dev.0
+    // resolve to `latest` dist-tag (0.1.0-dev.0) instead of the highest match,
+    // causing "export not found" errors when the scaffolding CLI is newer.
+    return channel ? version : `^${base}`;
+}
+/** Version range for @powerhousedao/ph-clint{,-dev} deps in scaffolded projects. */
+const PH_CLINT_VERSION = phClintRange(CLI_VERSION);
+const POWERHOUSE_VERSION_FALLBACK = '6.0.0-dev.170';
+let _powerhouseVersion;
+function getPowerhouseVersion() {
+    if (_powerhouseVersion === undefined) {
+        _powerhouseVersion = getPhVersion('ph') ?? POWERHOUSE_VERSION_FALLBACK;
+    }
+    return _powerhouseVersion;
+}
+export function buildCliPackageJson(spec) {
+    const { mastra, powerhouse } = spec.features;
+    const pkgName = getPackageName(spec);
+    const bin = getBinName(spec);
+    const dependencies = {
+        '@powerhousedao/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/mcp'] = '^1.4.1';
+        dependencies['@mastra/memory'] = '^1.13.1';
+    }
+    if (phAtLeast(powerhouse, 'Reactor')) {
+        const appPkg = getAppPackageName(spec);
+        const appDir = getAppDirName(spec);
+        dependencies[appPkg] = `file:../${appDir}`;
+        dependencies['@powerhousedao/reactor'] = getPowerhouseVersion();
+        dependencies['@powerhousedao/reactor-api'] = getPowerhouseVersion();
+        dependencies['@powerhousedao/shared'] = getPowerhouseVersion();
+        dependencies['document-model'] = getPowerhouseVersion();
+        // External reactor packages (non-app) as versioned dependencies.
+        // Compare bare names (without scope) so that a spec entry with
+        // packageName "foo-app" still matches the scoped "@scope/foo-app".
+        const appBare = appPkg.replace(/^@[^/]+\//, '');
+        for (const pkg of spec.packages) {
+            const pkgBare = pkg.packageName.replace(/^@[^/]+\//, '');
+            if (pkgBare === appBare)
+                continue;
+            dependencies[pkg.packageName] = 'latest';
+        }
+    }
+    const scripts = {
+        'build:skills': 'tsx scripts/build-skills.ts',
+        'build:manifest': 'build-manifest',
+        build: 'pnpm build:skills && tsc && pnpm build:manifest',
+        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';
+    }
+    // Single-layout: publish scripts live in the CLI package.json (which IS the
+    // root). Split-layout gets these from root-package-json.ts instead.
+    if (!phAtLeast(powerhouse, 'Reactor')) {
+        scripts['publish:dev'] = 'ph-publish dev -c ./publish.config.js';
+        scripts['publish:staging'] = 'ph-publish staging -c ./publish.config.js';
+        scripts['publish:production'] = 'ph-publish production -c ./publish.config.js';
+    }
+    const pkg = {
+        name: pkgName,
+        version: spec.version,
+        publishConfig: { access: 'public' },
+        type: 'module',
+    };
+    if (spec.description)
+        pkg.description = spec.description;
+    pkg.bin = { [bin]: './dist/main.js' };
+    pkg.files = ['dist'];
+    pkg.scripts = scripts;
+    pkg.dependencies = dependencies;
+    pkg.devDependencies = {
+        '@jest/globals': '^30.2.0',
+        '@types/node': '^25.5.2',
+        jest: '^30.2.0',
+        '@powerhousedao/ph-clint-dev': PH_CLINT_VERSION,
+        'ts-jest': '^29.4.6',
+        tsx: '^4.19.0',
+        typescript: '^6.0.2',
+        'typescript-eslint': '^8.33.0',
+    };
+    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,170 @@
+/**
+ * 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 { getAppPackageName, phAtLeast } from '../../spec/types.js';
+/** External packages that have document types (not the app package). */
+function getExternalPackages(spec) {
+    const appPkg = getAppPackageName(spec);
+    return spec.packages.filter((p) => p.packageName !== appPkg && p.documentTypes.length > 0);
+}
+export function buildCliTs(spec) {
+    const { mastra, routine, powerhouse } = spec.features;
+    const ph = powerhouse;
+    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(' */');
+    const needsRoot = phAtLeast(ph, 'Reactor') || mastra.enabled;
+    lines.push('// @clint:begin imports');
+    const phClintImports = ['defineCli'];
+    if (phAtLeast(ph, 'Reactor'))
+        phClintImports.push('buildDefaultReactor');
+    // proxy has no additional imports
+    lines.push(`import { ${phClintImports.join(', ')} } from '@powerhousedao/ph-clint';`);
+    if (needsRoot) {
+        lines.push("import path from 'node:path';");
+    }
+    lines.push(`import { CLI_NAME, CLI_VERSION${needsRoot ? ', CLI_ROOT' : ''} } from './config.js';`);
+    lines.push(`import { configSchema, secretsSchema } from './framework.js';`);
+    if (phAtLeast(ph, 'Reactor')) {
+        lines.push(`import { documentModels } from '${getAppPackageName(spec)}';`);
+        const extPkgs = getExternalPackages(spec);
+        for (let i = 0; i < extPkgs.length; i++) {
+            const alias = extPkgs.length === 1 ? 'extModels' : `extModels${i}`;
+            lines.push(`import { documentModels as ${alias} } from '${extPkgs[i].packageName}';`);
+        }
+    }
+    if (mastra.enabled) {
+        lines.push(`import { createAgent } from './agents/agent.js';`);
+    }
+    if (mastra.enabled && mastra.common?.enableChat) {
+        lines.push(`import { chatSessionWatchTrigger } from '@powerhousedao/clint-common/chat';`);
+    }
+    lines.push('// @clint:end imports');
+    lines.push('');
+    lines.push('export const cli = defineCli({');
+    lines.push('  name: CLI_NAME,');
+    lines.push('  version: CLI_VERSION,');
+    lines.push('  // @clint:begin root');
+    if (phAtLeast(ph, 'Reactor')) {
+        lines.push('  root: CLI_ROOT,');
+    }
+    lines.push('  // @clint:end root');
+    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 (mastra.enabled && mastra.common?.enableChat) {
+        lines.push('  triggers: [chatSessionWatchTrigger],');
+    }
+    else {
+        lines.push('  triggers: [],');
+    }
+    lines.push('  // @clint:end triggers');
+    lines.push('');
+    lines.push('  // @clint:begin prompts');
+    lines.push('  prompts: {');
+    if (mastra.enabled) {
+        lines.push("    artifacts: [path.join(CLI_ROOT, 'gen', 'skills'), path.join(CLI_ROOT, 'dist', 'gen', 'skills')],");
+    }
+    else {
+        lines.push('    artifacts: [],');
+    }
+    if (mastra.enabled && mastra.agentId) {
+        lines.push('    agents: {');
+        lines.push(`      '${mastra.agentId}': {`);
+        if (mastra.profiles.length > 0) {
+            lines.push(`        name: '${mastra.profiles[0].id}',`);
+            lines.push('        sections: [');
+            for (const p of mastra.profiles) {
+                lines.push(`          '${p.id}.md',`);
+            }
+            lines.push('        ],');
+        }
+        else {
+            lines.push("        name: 'AgentBase',");
+            lines.push("        sections: ['AgentBase.md'],");
+        }
+        lines.push('        skills: [],');
+        lines.push('      },');
+        lines.push('    },');
+    }
+    else {
+        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 proxy');
+    if (spec.deployment.proxyEnabled) {
+        lines.push('  proxyEnabled: true,');
+    }
+    lines.push('  // @clint:end proxy');
+    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 / for commands.',");
+    }
+    else {
+        lines.push("        'Type / for commands or /cli-docs for help.',");
+    }
+    lines.push("      ].join('\\n'),");
+    lines.push('  },');
+    lines.push('  // @clint:end interactive');
+    lines.push('});');
+    lines.push('');
+    lines.push('// @clint:begin reactor');
+    if (phAtLeast(ph, 'Reactor')) {
+        lines.push('cli.configureReactor({');
+        lines.push('  create: (ctx) =>');
+        lines.push('    buildDefaultReactor(ctx, {');
+        const extPkgs = getExternalPackages(spec);
+        if (extPkgs.length === 0) {
+            lines.push('      documentModels,');
+        }
+        else {
+            const aliases = extPkgs.map((_, i) => extPkgs.length === 1 ? 'extModels' : `extModels${i}`);
+            lines.push(`      documentModels: [...documentModels, ${aliases.map(a => `...${a}`).join(', ')}],`);
+        }
+        lines.push(`      drive: { name: '${spec.name}' },`);
+        lines.push('      subscriptions: {},');
+        lines.push('    }),');
+        lines.push(`  switchboard: { enabled: ${String(phAtLeast(ph, 'Switchboard'))} },`);
+        lines.push(`  connect: { enabled: ${String(phAtLeast(ph, 'Connect'))} },`);
+        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,11 @@
+export function buildConfigTs(_spec) {
+    const lines = [];
+    lines.push(`import { readPackageInfo } from '@powerhousedao/ph-clint';`);
+    lines.push('');
+    lines.push('const pkg = readPackageInfo(import.meta.url);');
+    lines.push('');
+    lines.push('export const CLI_ROOT = pkg.root;');
+    lines.push(`export const CLI_NAME = pkg.name.replace(/-cli$/, '');`);
+    lines.push('export const CLI_VERSION = pkg.version;');
+    return lines.join('\n') + '\n';
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Builds `src/agents/demo-agent.ts` — a deterministic echo agent fallback.
+ *
+ * Generated when `features.mastra.enabled` with full agent config so the real
+ * agent factory can fall back to demo mode when no API key is configured.
+ */
+import { type ClintProjectSpec } from '../../spec/types.js';
+export declare function buildDemoAgentTs(spec: ClintProjectSpec): string | null;

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

@@ -0,0 +1,50 @@
+export function buildDemoAgentTs(spec) {
+    const { mastra } = spec.features;
+    // Only needed alongside the real agent (which imports it)
+    if (!mastra.enabled || !mastra.agentId || mastra.models.length === 0)
+        return null;
+    const agentId = mastra.agentId;
+    const agentName = mastra.agentName ?? agentId;
+    const agentDescription = mastra.agentDescription;
+    const agentImage = mastra.agentImage;
+    return [
+        "import type { AgentProvider, StreamChunk } from '@powerhousedao/ph-clint';",
+        '',
+        '/**',
+        ' * Demo agent — deterministic echo responses without an API key.',
+        ' *',
+        ' * Echoes user prompts with conversation tracking per thread.',
+        ' */',
+        'export function createDemoAgent(): AgentProvider {',
+        '  const conversations = new Map<string, string[]>();',
+        '',
+        '  return {',
+        `    id: '${agentId}',`,
+        `    name: '${agentName}',`,
+        ...(agentDescription ? [`    description: ${JSON.stringify(agentDescription)},`] : []),
+        ...(agentImage ? [`    image: ${JSON.stringify(agentImage)},`] : []),
+        '    async *stream(prompt, opts) {',
+        "      const threadId = opts?.threadId ?? 'default';",
+        '      if (!conversations.has(threadId)) {',
+        '        conversations.set(threadId, []);',
+        '      }',
+        '      const history = conversations.get(threadId)!;',
+        '      history.push(prompt);',
+        '',
+        '      const turnCount = history.length;',
+        '      if (turnCount > 1) {',
+        '        yield {',
+        "          type: 'text-delta',",
+        '          text: `I understand you\'re continuing our conversation (turn ${turnCount}). `,',
+        '        } satisfies StreamChunk;',
+        '      }',
+        '      yield {',
+        "        type: 'text-delta',",
+        '        text: `You said: "${prompt}". I\'m the demo agent — set an API key for real LLM responses.`,',
+        '      } satisfies StreamChunk;',
+        '    },',
+        '  };',
+        '}',
+        '',
+    ].join('\n');
+}

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

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

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

@@ -0,0 +1,16 @@
+/**
+ * Builds `eslint.config.js` for the CLI — minimal TypeScript-ESLint config.
+ */
+export function buildEslintConfigJs() {
+    return [
+        '// @clint:begin eslint',
+        "import tseslint from 'typescript-eslint';",
+        '',
+        'export default tseslint.config(',
+        '  tseslint.configs.recommended,',
+        "  { ignores: ['dist/', 'gen/', 'coverage/'] },",
+        ');',
+        '// @clint:end eslint',
+        '',
+    ].join('\n');
+}

package/dist/codegen/builders/framework-gen-ts.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Builds `src/framework.gen.ts` — the fully machine-owned half of the
+ * typed-binding split. Regenerated on every `init` and `update`; holds the
+ * `defineRegistry([...])` call that describes which document models
+ * are bound into `framework.ts`'s typed factories.
+ *
+ * Iterates all packages' document types. The app package's modules are
+ * imported from the local `{name}-app` package; external packages' modules
+ * are imported from their npm package name.
+ *
+ * Document type entries may be explicit IDs (`powerhouse/ph-clint-project`)
+ * or glob patterns (`*​/*`, `powerhouse/*`, `acme/doc-*`).  Explicit IDs
+ * produce static named imports; glob patterns import the package's
+ * `documentModels` array and filter at runtime so newly-added document
+ * models are picked up without a codegen re-run.
+ *
+ * Emitted only when Powerhouse is enabled — flat-layout impls have no
+ * reactor package to import modules from and bind `createTypes` directly in
+ * `framework.ts`. When Powerhouse is on but no document types are declared,
+ * we still emit this file with an empty `defineRegistry([])` so impl code's
+ * `import { registry } from './framework.gen.js'` keeps resolving across
+ * regens.
+ */
+import { type ClintProjectSpec } from '../../spec/types.js';
+export declare function buildFrameworkGenTs(spec: ClintProjectSpec): string | null;

package/dist/codegen/builders/framework-gen-ts.js

@@ -0,0 +1,114 @@
+/**
+ * Builds `src/framework.gen.ts` — the fully machine-owned half of the
+ * typed-binding split. Regenerated on every `init` and `update`; holds the
+ * `defineRegistry([...])` call that describes which document models
+ * are bound into `framework.ts`'s typed factories.
+ *
+ * Iterates all packages' document types. The app package's modules are
+ * imported from the local `{name}-app` package; external packages' modules
+ * are imported from their npm package name.
+ *
+ * Document type entries may be explicit IDs (`powerhouse/ph-clint-project`)
+ * or glob patterns (`*​/*`, `powerhouse/*`, `acme/doc-*`).  Explicit IDs
+ * produce static named imports; glob patterns import the package's
+ * `documentModels` array and filter at runtime so newly-added document
+ * models are picked up without a codegen re-run.
+ *
+ * Emitted only when Powerhouse is enabled — flat-layout impls have no
+ * reactor package to import modules from and bind `createTypes` directly in
+ * `framework.ts`. When Powerhouse is on but no document types are declared,
+ * we still emit this file with an empty `defineRegistry([])` so impl code's
+ * `import { registry } from './framework.gen.js'` keeps resolving across
+ * regens.
+ */
+import { docTypeGlobToRegex, getAppPackageName, getDocumentTypeModuleName, getDocumentTypeSlug, isDocTypeGlob, phAtLeast, } from '../../spec/types.js';
+export function buildFrameworkGenTs(spec) {
+    if (!phAtLeast(spec.features.powerhouse, 'Reactor'))
+        return null;
+    const appPkg = getAppPackageName(spec);
+    // Collect entries across packages. Each package may contribute both
+    // explicit named imports and glob-based runtime filters.
+    const entries = [];
+    let globCounter = 0;
+    for (const pkg of spec.packages) {
+        const isApp = pkg.packageName === appPkg;
+        // Collect glob patterns for this package (may be multiple).
+        const globs = pkg.documentTypes.filter(isDocTypeGlob);
+        const explicits = pkg.documentTypes.filter((dt) => !isDocTypeGlob(dt));
+        for (const docType of explicits) {
+            const slug = getDocumentTypeSlug(docType);
+            entries.push({
+                kind: 'explicit',
+                name: getDocumentTypeModuleName(docType),
+                importFrom: isApp ? appPkg : `${pkg.packageName}/document-models/${slug}`,
+            });
+        }
+        if (globs.length > 0) {
+            // Merge all globs for this package into a single regex alternation.
+            const combined = globs.length === 1
+                ? docTypeGlobToRegex(globs[0])
+                : globs.map((g) => `(?:${docTypeGlobToRegex(g)})`).join('|');
+            const alias = globCounter === 0 ? 'globModels' : `globModels${globCounter}`;
+            globCounter++;
+            entries.push({
+                kind: 'glob',
+                modelsAlias: alias,
+                importFrom: isApp ? appPkg : pkg.packageName,
+                regexSource: combined,
+            });
+        }
+    }
+    const hasGlobs = entries.some((e) => e.kind === 'glob');
+    const lines = [];
+    lines.push('/**');
+    lines.push(' * THIS FILE IS GENERATED BY ph-clint-cli. DO NOT EDIT.');
+    lines.push(' *');
+    lines.push(' * Regenerated on every `ph-clint clint-project-regen` and on every spec-change');
+    lines.push(' * tick. Put custom bindings in `framework.ts`, not here — edits to');
+    lines.push(' * this file will be overwritten.');
+    lines.push(' */');
+    lines.push(`import { defineRegistry } from '@powerhousedao/ph-clint';`);
+    // Emit imports — named imports for explicit entries, documentModels for globs.
+    for (const e of entries) {
+        if (e.kind === 'explicit') {
+            lines.push(`import { ${e.name} } from '${e.importFrom}';`);
+        }
+        else {
+            lines.push(`import { documentModels as ${e.modelsAlias} } from '${e.importFrom}';`);
+        }
+    }
+    lines.push('');
+    lines.push('/**');
+    lines.push(' * Typed document registry derived from the reactor package\'s document models.');
+    lines.push(' * Regenerated whenever the spec\'s packages or document types change.');
+    lines.push(' */');
+    if (entries.length === 0) {
+        lines.push('export const registry = defineRegistry([] as const);');
+    }
+    else if (!hasGlobs) {
+        // Pure explicit — use `as const` for full type inference.
+        lines.push('export const registry = defineRegistry([');
+        for (const e of entries) {
+            if (e.kind === 'explicit') {
+                lines.push(`  ${e.name},`);
+            }
+        }
+        lines.push('] as const);');
+    }
+    else {
+        // Mix of explicit + glob — runtime filter loses `as const` inference.
+        lines.push('export const registry = defineRegistry([');
+        for (const e of entries) {
+            if (e.kind === 'explicit') {
+                lines.push(`  ${e.name},`);
+            }
+            else {
+                lines.push(`  ...${e.modelsAlias}.filter((m) => /${e.regexSource}/.test(m.documentModel.global.id)),`);
+            }
+        }
+        lines.push(']);');
+    }
+    lines.push('');
+    lines.push('export type Registry = typeof registry;');
+    return lines.join('\n') + '\n';
+}