@basaltkit/ai 0.10.0 → 1.0.0

package/dist/make/relations.js

@@ -0,0 +1,62 @@
+import { names } from '@basaltkit/generator';
+/**
+ * Real Prisma relations (Fase 6). A belongs-to relation on an entity generates:
+ * a `<name>Id` FK column, a `<name> <Model> @relation(...)` field, and — on the
+ * related model — an inverse `<plural> <This>[]` field. Both sides are required
+ * for Prisma to validate, so a relation to a model outside the plan is surfaced
+ * as a follow-up (the user adds the inverse field to their existing model).
+ */
+/** FK column name for a relation, e.g. `paciente` → `pacienteId`. */
+export function foreignKey(relation) {
+    return `${relation.name}Id`;
+}
+/** Synthetic FK fields (String) for an entity's relations — feed the Zod schema, mapper and columns. */
+export function relationForeignKeys(entity) {
+    return (entity.relations ?? []).map((r) => ({ name: foreignKey(r), type: 'String' }));
+}
+/** Prisma relation field lines for the entity's belongs-to relations. */
+export function relationFieldLines(entity) {
+    return (entity.relations ?? []).map((r) => `  ${r.name} ${names(r.model).pascal} @relation(fields: [${foreignKey(r)}], references: [id])`);
+}
+/** Inverse `hasMany` lines to add to `modelName`, from every other entity that belongs to it. */
+export function inverseRelationLines(modelName, allEntities) {
+    const target = names(modelName).pascal;
+    const lines = [];
+    for (const other of allEntities) {
+        if (names(other.name).pascal === target)
+            continue;
+        for (const r of other.relations ?? []) {
+            if (names(r.model).pascal === target) {
+                lines.push(`  ${pluralCamel(other.name)} ${names(other.name).pascal}[]`);
+            }
+        }
+    }
+    return lines;
+}
+/** Insert relation + inverse lines into a generated Prisma model, before its closing brace. */
+export function injectPrismaRelations(content, relationLines, inverseLines) {
+    const all = [...relationLines, ...inverseLines];
+    if (all.length === 0)
+        return { content, injected: false };
+    const out = content.replace(/\n\}\s*$/, `\n${all.join('\n')}\n}\n`);
+    return { content: out, injected: out !== content };
+}
+/** Relation targets that aren't generated in this plan (need a manual inverse field). */
+export function externalRelationTargets(entities) {
+    const planModels = new Set(entities.map((e) => names(e.name).pascal));
+    const external = new Set();
+    for (const e of entities) {
+        for (const r of e.relations ?? []) {
+            const target = names(r.model).pascal;
+            if (!planModels.has(target))
+                external.add(target);
+        }
+    }
+    return [...external];
+}
+function pluralCamel(name) {
+    return names(name)
+        .pluralKebab.split('-')
+        .map((part, i) => (i === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1)))
+        .join('');
+}

package/dist/make/render.d.ts

@@ -0,0 +1,4 @@
+import type { LineWriter } from '../render.js';
+import type { MakeResult } from './types.js';
+/** Render a {@link MakeResult} — what was generated, the review gate and follow-ups. */
+export declare function renderMakeResult(result: MakeResult, io: LineWriter): void;

package/dist/make/render.js

@@ -0,0 +1,66 @@
+const REVIEW_MARK = { pass: '✓', warn: '⚠', fail: '✗' };
+/** Render a {@link MakeResult} — what was generated, the review gate and follow-ups. */
+export function renderMakeResult(result, io) {
+    for (const resource of result.resources) {
+        const verb = result.dryRun ? 'Would generate' : 'Generated';
+        const extras = [
+            resource.augmented ? 'domain fields' : null,
+            resource.guarded ? 'permission guards' : null,
+            resource.audited ? 'audit' : null,
+        ].filter((x) => x !== null);
+        const tag = extras.length > 0 ? ` (+ ${extras.join(', ')})` : '';
+        io.log(`${verb} ${resource.name}${tag}:`);
+        const paths = result.dryRun ? resource.files.map((f) => f.path) : resource.written;
+        for (const path of paths)
+            io.log(`  ${result.dryRun ? '~' : '+'} ${path}`);
+        if (!result.dryRun) {
+            io.log(resource.registered ? '  ✓ wired into src/app.ts' : '  • src/app.ts not auto-wired');
+        }
+        if (resource.note)
+            io.log(`  ⚠ ${resource.note}`);
+        io.log('');
+    }
+    if (result.schema) {
+        const s = result.schema;
+        if (!s.found) {
+            io.log(`Schema: ${s.path} not found — add the model(s) manually.`);
+        }
+        else {
+            const parts = [];
+            if (s.merged.length > 0)
+                parts.push(`${result.dryRun ? 'would merge' : 'merged'} ${s.merged.join(', ')}`);
+            if (s.skipped.length > 0)
+                parts.push(`already present: ${s.skipped.join(', ')}`);
+            io.log(`Schema (${s.path}): ${parts.length > 0 ? parts.join('; ') : 'no change'}`);
+        }
+    }
+    if (result.migration) {
+        io.log(result.migration.ok ? 'Migration: ✓ prisma db push' : 'Migration: ✗ prisma db push failed');
+        if (!result.migration.ok) {
+            for (const line of result.migration.output.split('\n').slice(-6))
+                io.log(`  ${line}`);
+        }
+    }
+    if (result.schema || result.migration)
+        io.log('');
+    io.log('Review:');
+    for (const item of result.review.items) {
+        io.log(`  ${REVIEW_MARK[item.status]} ${item.label} — ${item.detail}`);
+    }
+    io.log('');
+    if (result.followUps.length > 0) {
+        io.log('Next steps (manual):');
+        for (const step of result.followUps)
+            io.log(`  - ${step}`);
+        io.log('');
+    }
+    if (result.dryRun) {
+        io.log('Dry run — nothing was written. Re-run without --dry-run to apply.');
+    }
+    else if (result.review.ok) {
+        io.log('✓ Implementation completed.');
+    }
+    else {
+        io.log('✗ Implementation completed with blocking review issues — see above.');
+    }
+}

package/dist/make/repository.d.ts

@@ -0,0 +1,16 @@
+import type { PlanField } from '../plan/types.js';
+export interface RepositoryOptions {
+    softDelete: boolean;
+    /** Scope every query by tenantId from context (portable — no global extension needed). */
+    tenantScoped: boolean;
+    /** Keep the generator's base `name` column. */
+    keepName: boolean;
+}
+/**
+ * Render a complete Prisma repository for a resource — replacing the generator's,
+ * which (a) only maps id/name/timestamps (dropping domain fields) and (b) relies
+ * on the global tenancy extension to stamp tenantId. This one maps every domain
+ * field and, when tenant-scoped, scopes tenantId explicitly from the request
+ * context, so it works even on a raw client shared with non-tenant models.
+ */
+export declare function renderPrismaRepository(name: string, fields: PlanField[], options: RepositoryOptions): string;

package/dist/make/repository.js

@@ -0,0 +1,176 @@
+import { names } from '@basaltkit/generator';
+import { canonicalType, domainFields } from './fields.js';
+/** TypeScript type of a Prisma row column for the mapper's parameter. */
+function rowType(t) {
+    switch (t) {
+        case 'Int':
+        case 'Float':
+            return 'number';
+        case 'Boolean':
+            return 'boolean';
+        case 'DateTime':
+            return 'Date';
+        case 'Json':
+            return 'unknown';
+        case 'String':
+            return 'string';
+    }
+}
+/** Expression mapping a Prisma row column to the API type (dates → ISO strings). */
+function mapExpr(field, t) {
+    return t === 'DateTime' ? `r.${field}.toISOString()` : `r.${field}`;
+}
+/**
+ * Render a complete Prisma repository for a resource — replacing the generator's,
+ * which (a) only maps id/name/timestamps (dropping domain fields) and (b) relies
+ * on the global tenancy extension to stamp tenantId. This one maps every domain
+ * field and, when tenant-scoped, scopes tenantId explicitly from the request
+ * context, so it works even on a raw client shared with non-tenant models.
+ */
+export function renderPrismaRepository(name, fields, options) {
+    const n = names(name);
+    const { softDelete, tenantScoped, keepName } = options;
+    const bodyFields = [];
+    if (keepName)
+        bodyFields.push({ name: 'name', canon: 'String' });
+    for (const f of domainFields(fields)) {
+        bodyFields.push({ name: f.name, canon: canonicalType(f.type), ...(f.enum && f.enum.length > 0 ? { values: f.enum } : {}) });
+    }
+    // Enum columns are stored as String; the mapper narrows them to the union.
+    const colType = (f) => (f.values ? 'string' : rowType(f.canon));
+    const colExpr = (f) => f.values ? `r.${f.name} as ${f.values.map((v) => `'${v}'`).join(' | ')}` : mapExpr(f.name, f.canon);
+    const rowTypeEntries = [
+        'id: string',
+        ...bodyFields.map((f) => `${f.name}: ${colType(f)}`),
+        'createdAt: Date',
+        'updatedAt: Date',
+        ...(softDelete ? ['deletedAt: Date | null'] : []),
+    ].join('; ');
+    const mapLines = [
+        '  id: r.id,',
+        ...bodyFields.map((f) => `  ${f.name}: ${colExpr(f)},`),
+        '  createdAt: r.createdAt.toISOString(),',
+        '  updatedAt: r.updatedAt.toISOString(),',
+        ...(softDelete ? ['  deletedAt: r.deletedAt ? r.deletedAt.toISOString() : null,'] : []),
+    ].join('\n');
+    const tenant = (soft) => ['id', tenantScoped ? 'tenantId: currentTenantId()' : '', soft && softDelete ? 'deletedAt: null' : '']
+        .filter(Boolean)
+        .join(', ');
+    const listWhere = [tenantScoped ? 'tenantId: currentTenantId()' : '', softDelete ? 'deletedAt: null' : '']
+        .filter(Boolean)
+        .join(', ');
+    const createData = tenantScoped ? '{ ...input, tenantId: currentTenantId() }' : 'input';
+    const updateMethod = tenantScoped
+        ? `  async update(id: string, input: Update${n.pascal}Input): Promise<${n.pascal} | null> {
+    const res = await this.records.updateMany({ where: { ${tenant(true)} }, data: input })
+    return res.count > 0 ? this.find(id) : null
+  }`
+        : `  async update(id: string, input: Update${n.pascal}Input): Promise<${n.pascal} | null> {
+    try {
+      return to${n.pascal}(await this.records.update({ where: { id }, data: input }))
+    } catch {
+      return null
+    }
+  }`;
+    const deleteMethod = renderDelete(tenantScoped, softDelete);
+    const restoreMethod = softDelete ? `\n\n${renderRestore(tenantScoped)}` : '';
+    const interfaceRestore = softDelete ? `\n  restore(id: string): Promise<boolean>` : '';
+    const coreImport = tenantScoped ? 'createToken, tryCtx' : 'createToken';
+    const httpImport = tenantScoped ? `\nimport { HttpError } from '@basaltkit/fastify'` : '';
+    const tenantHelper = tenantScoped
+        ? `
+// Tenant-scoped model. Scoped by tenantId explicitly from the request context, so
+// it works even on a raw client shared with non-tenant models (no global extension).
+// A missing tenant is a client error (400) — never a silent 500.
+const currentTenantId = (): string => {
+  const id = (tryCtx()?.['tenant'] as { id?: string } | undefined)?.id
+  if (!id) throw new HttpError(400, 'TENANT_REQUIRED', 'No tenant in context — send the x-tenant-id header (or resolve a tenant first).')
+  return id
+}
+`
+        : '';
+    return `import { ${coreImport} } from '@basaltkit/core'
+import { db } from '@basaltkit/prisma'${httpImport}
+import type { PrismaClient } from '@prisma/client'
+import type { ${n.pascal}, Create${n.pascal}Input, Update${n.pascal}Input } from './${n.kebab}.schema.js'
+${tenantHelper}
+// Map the Prisma row (Date columns) to the API type (ISO-string timestamps).
+const to${n.pascal} = (r: { ${rowTypeEntries} }): ${n.pascal} => ({
+${mapLines}
+})
+
+export interface ${n.pascal}Repository {
+  list(): Promise<${n.pascal}[]>
+  find(id: string): Promise<${n.pascal} | null>
+  create(input: Create${n.pascal}Input): Promise<${n.pascal}>
+  update(id: string, input: Update${n.pascal}Input): Promise<${n.pascal} | null>
+  delete(id: string): Promise<boolean>${interfaceRestore}
+}
+
+export class Prisma${n.pascal}Repository implements ${n.pascal}Repository {
+  private get records() {
+    return db<PrismaClient>().${n.camel}
+  }
+
+  async list(): Promise<${n.pascal}[]> {
+    return (await this.records.findMany(${listWhere ? `{ where: { ${listWhere} } }` : ''})).map(to${n.pascal})
+  }
+
+  async find(id: string): Promise<${n.pascal} | null> {
+    const r = await this.records.findFirst({ where: { ${tenant(true)} } })
+    return r ? to${n.pascal}(r) : null
+  }
+
+  async create(input: Create${n.pascal}Input): Promise<${n.pascal}> {
+    return to${n.pascal}(await this.records.create({ data: ${createData} }))
+  }
+
+${updateMethod}
+
+${deleteMethod}${restoreMethod}
+}
+
+export const ${n.constant}_REPOSITORY = createToken<${n.pascal}Repository>('${n.kebab}.repository')
+`;
+}
+function renderDelete(tenantScoped, softDelete) {
+    if (tenantScoped) {
+        const where = softDelete
+            ? 'id, tenantId: currentTenantId(), deletedAt: null'
+            : 'id, tenantId: currentTenantId()';
+        const op = softDelete
+            ? `updateMany({ where: { ${where} }, data: { deletedAt: new Date() } })`
+            : `deleteMany({ where: { ${where} } })`;
+        return `  async delete(id: string): Promise<boolean> {
+    const res = await this.records.${op}
+    return res.count > 0
+  }`;
+    }
+    const op = softDelete
+        ? `update({ where: { id }, data: { deletedAt: new Date() } })`
+        : `delete({ where: { id } })`;
+    return `  async delete(id: string): Promise<boolean> {
+    try {
+      await this.records.${op}
+      return true
+    } catch {
+      return false
+    }
+  }`;
+}
+function renderRestore(tenantScoped) {
+    if (tenantScoped) {
+        return `  async restore(id: string): Promise<boolean> {
+    const res = await this.records.updateMany({ where: { id, tenantId: currentTenantId() }, data: { deletedAt: null } })
+    return res.count > 0
+  }`;
+    }
+    return `  async restore(id: string): Promise<boolean> {
+    try {
+      await this.records.update({ where: { id }, data: { deletedAt: null } })
+      return true
+    } catch {
+      return false
+    }
+  }`;
+}

package/dist/make/schema.d.ts

@@ -0,0 +1,22 @@
+export interface ModelBlock {
+    name: string;
+    block: string;
+}
+/** Extract the `model <Name> { … }` block from a generated `.prisma` snippet. */
+export declare function extractModelBlock(snippet: string): ModelBlock | null;
+export interface MergeOutcome {
+    content: string;
+    merged: string[];
+    skipped: string[];
+}
+/** Append model blocks to a schema, skipping any model already declared (idempotent). */
+export declare function mergeModelsIntoSchema(schema: string, blocks: ModelBlock[]): MergeOutcome;
+export declare function readSchema(baseDir: string, schemaPath: string): Promise<string | null>;
+export declare function writeSchema(baseDir: string, schemaPath: string, content: string): Promise<void>;
+export interface PrismaPushResult {
+    ok: boolean;
+    /** Tail of stdout/stderr. */
+    output: string;
+}
+/** Run `npx prisma db push` — creates the table(s) and regenerates the client. Best-effort. */
+export declare function runPrismaPush(baseDir: string): Promise<PrismaPushResult>;

package/dist/make/schema.js

@@ -0,0 +1,54 @@
+import { execFile } from 'node:child_process';
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+const run = promisify(execFile);
+/** Extract the `model <Name> { … }` block from a generated `.prisma` snippet. */
+export function extractModelBlock(snippet) {
+    const match = /model\s+(\w+)\s*\{[\s\S]*?\n\}/.exec(snippet);
+    if (!match || !match[1])
+        return null;
+    return { name: match[1], block: match[0] };
+}
+/** Append model blocks to a schema, skipping any model already declared (idempotent). */
+export function mergeModelsIntoSchema(schema, blocks) {
+    let content = schema.replace(/\s*$/, '');
+    const merged = [];
+    const skipped = [];
+    for (const { name, block } of blocks) {
+        if (new RegExp(`\\bmodel\\s+${name}\\s*\\{`).test(content)) {
+            skipped.push(name);
+            continue;
+        }
+        content += `\n\n${block.trim()}\n`;
+        merged.push(name);
+    }
+    return { content: content.endsWith('\n') ? content : `${content}\n`, merged, skipped };
+}
+export async function readSchema(baseDir, schemaPath) {
+    try {
+        return await readFile(join(baseDir, schemaPath), 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeSchema(baseDir, schemaPath, content) {
+    await writeFile(join(baseDir, schemaPath), content);
+}
+/** Run `npx prisma db push` — creates the table(s) and regenerates the client. Best-effort. */
+export async function runPrismaPush(baseDir) {
+    try {
+        const { stdout } = await run('npx', ['prisma', 'db', 'push'], {
+            cwd: baseDir,
+            timeout: 180_000,
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        return { ok: true, output: stdout.slice(-2000) };
+    }
+    catch (error) {
+        const e = error;
+        const output = (e.stdout ?? '') + (e.stderr ?? '') || e.message || 'unknown error';
+        return { ok: false, output: output.slice(-3000) };
+    }
+}

package/dist/make/types.d.ts

@@ -0,0 +1,77 @@
+import type { GeneratedFile } from '@basaltkit/generator';
+export interface MakeOptions {
+    /** Skip writing to disk — return what would be generated. */
+    dryRun?: boolean;
+    /** Overwrite existing files instead of refusing. */
+    force?: boolean;
+    /** Project root. Defaults to process.cwd(). */
+    baseDir?: string;
+    /** Force a Prisma-backed resource (default: inferred from the stack). */
+    prisma?: boolean;
+    /** Force soft-delete (default: from the plan's generator command). */
+    softDelete?: boolean;
+    /** Path to the Prisma schema to merge models into. Default `prisma/schema.prisma`. */
+    schemaPath?: string;
+    /** After merging models, run `prisma db push` (creates tables + regenerates the client). */
+    migrate?: boolean;
+}
+/** How the generated models were merged into prisma/schema.prisma. */
+export interface SchemaMerge {
+    path: string;
+    /** The schema file was found on disk. */
+    found: boolean;
+    /** Models appended. */
+    merged: string[];
+    /** Models already present (left as is). */
+    skipped: string[];
+    /** The schema file was written (false on dry-run). */
+    written: boolean;
+}
+/** Result of an opt-in `prisma db push`. */
+export interface Migration {
+    ok: boolean;
+    /** Tail of the command output. */
+    output: string;
+}
+export interface ResourceBuild {
+    name: string;
+    prisma: boolean;
+    softDelete: boolean;
+    /** Generated (and domain-augmented) files. */
+    files: GeneratedFile[];
+    /** Domain fields were injected into schema/model. */
+    augmented: boolean;
+    /** Permission `meta.can` guards were injected into the routes. */
+    guarded: boolean;
+    /** Audit recording was injected into the service + plugin. */
+    audited: boolean;
+    /** Files actually written (empty on dry-run or on clash). */
+    written: string[];
+    /** Wired into src/app.ts. */
+    registered: boolean;
+    /** Why a step didn't complete (e.g. a file clash). */
+    note?: string;
+}
+export type ReviewStatus = 'pass' | 'warn' | 'fail';
+export interface ReviewItem {
+    label: string;
+    status: ReviewStatus;
+    detail: string;
+}
+export interface ReviewResult {
+    items: ReviewItem[];
+    /** True when no item failed. */
+    ok: boolean;
+}
+export interface MakeResult {
+    request: string;
+    dryRun: boolean;
+    resources: ResourceBuild[];
+    /** How models were merged into the Prisma schema (undefined when no Prisma resource). */
+    schema?: SchemaMerge;
+    /** Result of `--migrate` (undefined when not requested). */
+    migration?: Migration;
+    /** Manual follow-ups the scaffold can't do yet. */
+    followUps: string[];
+    review: ReviewResult;
+}

package/dist/make/types.js

@@ -0,0 +1 @@
+export {};

package/dist/make/verify.d.ts

@@ -0,0 +1,12 @@
+export interface VerifyResult {
+    ok: boolean;
+    /** Command that was run, e.g. `pnpm typecheck`. */
+    command: string;
+    /** Combined stdout/stderr tail on failure. */
+    output: string;
+}
+/**
+ * Run the project's typecheck as a review gate (spec §12/§20). Best-effort: if
+ * the command is missing or errors, it reports failure rather than throwing.
+ */
+export declare function verifyProject(baseDir: string, command?: string, args?: string[]): Promise<VerifyResult>;

package/dist/make/verify.js

@@ -0,0 +1,19 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const run = promisify(execFile);
+/**
+ * Run the project's typecheck as a review gate (spec §12/§20). Best-effort: if
+ * the command is missing or errors, it reports failure rather than throwing.
+ */
+export async function verifyProject(baseDir, command = 'pnpm', args = ['-s', 'typecheck']) {
+    const label = `${command} ${args.join(' ')}`;
+    try {
+        await run(command, args, { cwd: baseDir, timeout: 180_000, maxBuffer: 10 * 1024 * 1024 });
+        return { ok: true, command: label, output: '' };
+    }
+    catch (error) {
+        const e = error;
+        const output = (e.stdout ?? '') + (e.stderr ?? '') || e.message || 'unknown error';
+        return { ok: false, command: label, output: output.slice(-4000) };
+    }
+}

package/dist/make/wire.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Inject `meta: { can: '<prefix>.<action>' }` into every generated route, so the
+ * permissions guard enforces it. `prefix` is the resource's permission namespace
+ * (e.g. `patients`) — derived per entity by the caller, so each entity in a
+ * multi-entity plan gets its own correct permission, not a shared one.
+ */
+export declare function injectPermissionGuards(content: string, prefix: string): {
+    content: string;
+    injected: boolean;
+};
+/**
+ * Inject audit recording into the generated service: the constructor receives an
+ * `Audit`, and create/update/remove record their event after the repository call.
+ */
+export declare function injectAuditService(content: string, resourceName: string, events: string[]): {
+    content: string;
+    injected: boolean;
+};
+/** Inject the `AUDIT` dependency into the generated plugin's service construction. */
+export declare function injectAuditPlugin(content: string, resourceName: string): {
+    content: string;
+    injected: boolean;
+};

package/dist/make/wire.js

@@ -0,0 +1,76 @@
+import { names } from '@basaltkit/generator';
+function insertAfterLastImport(content, line) {
+    const imports = [...content.matchAll(/^import .*$/gm)];
+    const last = imports.at(-1);
+    if (!last || last.index === undefined)
+        return `${line}\n${content}`;
+    const at = last.index + last[0].length;
+    return `${content.slice(0, at)}\n${line}${content.slice(at)}`;
+}
+function actionFor(method, url) {
+    switch (method.toUpperCase()) {
+        case 'GET':
+            return 'view';
+        case 'POST':
+            return url.endsWith('/restore') ? 'update' : 'create';
+        case 'PATCH':
+        case 'PUT':
+            return 'update';
+        case 'DELETE':
+            return 'delete';
+        default:
+            return null;
+    }
+}
+/**
+ * Inject `meta: { can: '<prefix>.<action>' }` into every generated route, so the
+ * permissions guard enforces it. `prefix` is the resource's permission namespace
+ * (e.g. `patients`) — derived per entity by the caller, so each entity in a
+ * multi-entity plan gets its own correct permission, not a shared one.
+ */
+export function injectPermissionGuards(content, prefix) {
+    if (!prefix)
+        return { content, injected: false };
+    let injected = false;
+    const out = content.replace(/route\(\{\s*\n(\s*)method: '(\w+)',\s*\n\s*url: '([^']*)',/g, (match, indent, method, url) => {
+        const action = actionFor(method, url);
+        if (!action)
+            return match;
+        injected = true;
+        return `route({\n${indent}method: '${method}',\n${indent}url: '${url}',\n${indent}meta: { can: '${prefix}.${action}' },`;
+    });
+    return { content: out, injected };
+}
+function eventFor(events, suffix) {
+    const match = events.find((e) => e.endsWith(`.${suffix}`));
+    if (match)
+        return match;
+    const prefix = events[0]?.split('.')[0] ?? 'record';
+    return `${prefix}.${suffix}`;
+}
+/**
+ * Inject audit recording into the generated service: the constructor receives an
+ * `Audit`, and create/update/remove record their event after the repository call.
+ */
+export function injectAuditService(content, resourceName, events) {
+    const n = names(resourceName);
+    const ctorAnchor = `constructor(private readonly repository: ${n.pascal}Repository) {}`;
+    if (!content.includes(ctorAnchor))
+        return { content, injected: false };
+    let out = insertAfterLastImport(content, `import type { Audit } from '@basaltkit/audit'`);
+    out = out.replace(ctorAnchor, `constructor(\n    private readonly repository: ${n.pascal}Repository,\n    private readonly audit: Audit,\n  ) {}`);
+    out = out.replace(`  create(input: Create${n.pascal}Input) {\n    return this.repository.create(input)\n  }`, `  async create(input: Create${n.pascal}Input) {\n    const created = await this.repository.create(input)\n    await this.audit.record('${eventFor(events, 'created')}', created)\n    return created\n  }`);
+    out = out.replace(`  update(id: string, input: Update${n.pascal}Input) {\n    return this.repository.update(id, input)\n  }`, `  async update(id: string, input: Update${n.pascal}Input) {\n    const updated = await this.repository.update(id, input)\n    if (updated) await this.audit.record('${eventFor(events, 'updated')}', updated)\n    return updated\n  }`);
+    out = out.replace(`  remove(id: string) {\n    return this.repository.delete(id)\n  }`, `  async remove(id: string) {\n    const removed = await this.repository.delete(id)\n    if (removed) await this.audit.record('${eventFor(events, 'deleted')}', { id })\n    return removed\n  }`);
+    return { content: out, injected: true };
+}
+/** Inject the `AUDIT` dependency into the generated plugin's service construction. */
+export function injectAuditPlugin(content, resourceName) {
+    const n = names(resourceName);
+    const anchor = `new ${n.pascal}Service(c.get(${n.constant}_REPOSITORY))`;
+    if (!content.includes(anchor))
+        return { content, injected: false };
+    let out = insertAfterLastImport(content, `import { AUDIT } from '@basaltkit/audit'`);
+    out = out.replace(anchor, `new ${n.pascal}Service(c.get(${n.constant}_REPOSITORY), c.get(AUDIT))`);
+    return { content: out, injected: true };
+}

package/dist/plan/context.d.ts

@@ -0,0 +1,8 @@
+import type { ProjectContext } from '../context/project.js';
+/**
+ * Compact, relevant-only project summary for the planner (spec §18 Context
+ * Engineering — never ship the whole project to the model). Surfaces exactly what
+ * the Architect needs to ground a plan: enabled capabilities, existing models and
+ * the generator's flags.
+ */
+export declare function buildPlanContext(ctx: ProjectContext): string;

package/dist/plan/context.js

@@ -0,0 +1,39 @@
+/**
+ * Compact, relevant-only project summary for the planner (spec §18 Context
+ * Engineering — never ship the whole project to the model). Surfaces exactly what
+ * the Architect needs to ground a plan: enabled capabilities, existing models and
+ * the generator's flags.
+ */
+export function buildPlanContext(ctx) {
+    const s = ctx.stack;
+    const caps = [
+        s.http ? `HTTP: ${s.http}` : null,
+        s.orm ? `ORM: ${s.orm}` : null,
+        s.database ? `database: ${s.database}` : null,
+        s.tenancy ? 'tenancy: ENABLED — tenant-owned models must carry tenantId' : 'tenancy: off',
+        s.auth ? 'auth: enabled' : null,
+        s.rbac ? 'RBAC: enabled — register <resource>.view/create/update/delete' : null,
+        s.audit ? 'audit: enabled — emit <resource>.created/updated/deleted' : null,
+        s.subscriptions ? 'subscriptions: enabled' : null,
+        s.payments ? 'payments: enabled' : null,
+        s.queue ? 'queue: enabled' : null,
+        s.search ? 'search: enabled' : null,
+        s.events ? 'events: enabled' : null,
+        s.scheduler ? 'scheduler: enabled' : null,
+        s.storage ? 'storage: enabled' : null,
+    ].filter((line) => line !== null);
+    const models = ctx.prisma && ctx.prisma.models.length > 0
+        ? ctx.prisma.models.map((m) => `${m.name}${m.tenantScoped ? ' (tenantId)' : ''}`).join(', ')
+        : '(none)';
+    const lines = [
+        'PROJECT STACK:',
+        ...caps.map((c) => `- ${c}`),
+        '',
+        `EXISTING PRISMA MODELS: ${models}`,
+        '',
+        'GENERATOR: `basalt make:resource <Name>` — flags: --prisma, --soft-delete, --no-register, --dir, --force.',
+    ];
+    if (ctx.app)
+        lines.push(`APP FILE: ${ctx.app.path} (wired plugins: ${ctx.app.plugins.join(', ') || 'none'}).`);
+    return lines.join('\n');
+}