@basaltkit/ai 1.6.1 → 1.6.2

package/dist/commands.js

@@ -4,7 +4,7 @@ import { detectProject, nodeReader } from './context/project.js';
 import { hasErrors, runDoctor } from './doctor/run.js';
 import { applyFixEdits, fixableIds, planFix, renderFixes } from './doctor/fixes.js';
 import { createProvider, providerEnvFromProcess } from './provider/factory.js';
-import { createPlan } from './plan/plan.js';
+import { createPlan, withGeneratorEntities } from './plan/plan.js';
 import { renderPlan } from './plan/render.js';
 import { packageSteps, runMake } from './make/make.js';
 import { renderMakeResult } from './make/render.js';
@@ -140,7 +140,7 @@ export function aiCommands(options = {}) {
                 io.log('Planning...');
                 io.log('');
                 try {
-                    const plan = await createPlan(provider, ctx, request);
+                    const plan = withGeneratorEntities(await createPlan(provider, ctx, request), ctx);
                     renderPlan(plan, io);
                     return 0;
                 }
@@ -174,7 +174,8 @@ export function aiCommands(options = {}) {
                 io.log('');
                 let plan;
                 try {
-                    plan = await createPlan(provider, ctx, request);
+                    // Shown and built with an entity for every generator step.
+                    plan = withGeneratorEntities(await createPlan(provider, ctx, request), ctx);
                 }
                 catch (error) {
                     io.error(error.message);

package/dist/context/project.d.ts

@@ -35,9 +35,18 @@ export interface DetectedStack {
     logger: boolean;
     ai: boolean;
 }
+/** A model column as declared: `type` keeps Prisma's spelling minus `?`/`[]`. */
+export interface PrismaColumn {
+    name: string;
+    type: string;
+    optional: boolean;
+    list: boolean;
+}
 export interface PrismaModel {
     name: string;
     fields: string[];
+    /** The same fields with their types, so a resource can be generated for an existing model. */
+    columns?: PrismaColumn[];
     /** True when the model carries a `tenantId` column (tenant-scoped). */
     tenantScoped: boolean;
     /** The `@@map("…")` table name, when the model declares one. */

package/dist/context/project.js

@@ -506,12 +506,17 @@ function parseModels(schema) {
         const body = match[2];
         if (!name || body === undefined)
             continue;
-        const fields = body
-            .split('\n')
-            .map((line) => line.trim().split(/\s+/)[0])
-            .filter((token) => !!token && !token.startsWith('@') && !token.startsWith('//'));
+        const columns = [];
+        for (const line of body.split('\n')) {
+            const [field, rawType] = line.trim().split(/\s+/);
+            if (!field || field.startsWith('@') || field.startsWith('//'))
+                continue;
+            const type = (rawType ?? '').replace(/[?[\]]/g, '');
+            columns.push({ name: field, type, optional: rawType?.endsWith('?') === true, list: rawType?.endsWith('[]') === true });
+        }
+        const fields = columns.map((c) => c.name);
         const table = /@@map\(\s*"([^"]+)"\s*\)/.exec(body)?.[1];
-        models.push({ name, fields, tenantScoped: fields.includes('tenantId'), ...(table ? { table } : {}) });
+        models.push({ name, fields, columns, tenantScoped: fields.includes('tenantId'), ...(table ? { table } : {}) });
     }
     return models;
 }

package/dist/index.d.ts

@@ -6,13 +6,13 @@ export { fetchWithRetry, type RetryOptions } from './provider/http.js';
 export { globalSseFetch, parseSseContent, type SseFetch, type SseResponse } from './provider/sse.js';
 export { createProvider, providerEnvFrom, providerEnvFromProcess, type CreateProviderOptions, type ProviderEnv, type ProviderName, } from './provider/factory.js';
 export { runGeneration, generateText, withAbort, throwIfAborted, abortError, isAbortError, type OnProgress, type WorkflowProgress, type WorkflowRunOptions, } from './generate.js';
-export { detectProject, nodeReader, memoryReader, type AppFileInfo, type CentralPlatformRouteHint, type DefaultMemoryStore, type DetectedStack, type EnvFileInfo, type FrameworkSchema, type MigrationsInfo, type PrismaInfo, type PrismaModel, type ProjectContext, type ProjectReader, type ServerFileInfo, type SourceHint, type SourceHints, } from './context/project.js';
+export { detectProject, nodeReader, memoryReader, type AppFileInfo, type CentralPlatformRouteHint, type DefaultMemoryStore, type DetectedStack, type EnvFileInfo, type FrameworkSchema, type MigrationsInfo, type PrismaInfo, type PrismaColumn, type PrismaModel, type ProjectContext, type ProjectReader, type ServerFileInfo, type SourceHint, type SourceHints, } from './context/project.js';
 export { defineRule, type Diagnostic, type DiagnosticCategory, type DoctorRule, type Severity, } from './doctor/types.js';
 export { DEFAULT_RULES } from './doctor/rules.js';
 export { hasErrors, runDoctor } from './doctor/run.js';
 export { applyFixEdits, fixableIds, planFix, renderFixes, FIXES, type FileEdit, type FixApplier, type FixOutcome, type FixStatus, } from './doctor/fixes.js';
 export { analyze, type AnalysisReport } from './analyze/run.js';
-export { createPlan, parsePlan, type CreatePlanOptions } from './plan/plan.js';
+export { createPlan, generatorTargets, parsePlan, withGeneratorEntities, type CreatePlanOptions } from './plan/plan.js';
 export { buildPlanContext } from './plan/context.js';
 export { BASALT_KNOWLEDGE } from './plan/knowledge.js';
 export { ECOSYSTEM_PACKAGES, renderEcosystemCatalog, type EcosystemPackage } from './plan/packages.js';

package/dist/index.js

@@ -18,7 +18,7 @@ export { applyFixEdits, fixableIds, planFix, renderFixes, FIXES, } from './docto
 // Analysis report (spec §5, Analyze).
 export { analyze } from './analyze/run.js';
 // Planning (spec §3, Plan mode) — natural language → architecture plan.
-export { createPlan, parsePlan } from './plan/plan.js';
+export { createPlan, generatorTargets, parsePlan, withGeneratorEntities } from './plan/plan.js';
 export { buildPlanContext } from './plan/context.js';
 export { BASALT_KNOWLEDGE } from './plan/knowledge.js';
 export { ECOSYSTEM_PACKAGES, renderEcosystemCatalog } from './plan/packages.js';

package/dist/make/make.d.ts

@@ -11,6 +11,6 @@ import type { MakeOptions, MakeResult } from './types.js';
  * decided. No destructive operations — never overwrites without `force`, never
  * touches the database, never deletes.
  */
-export declare function runMake(ctx: ProjectContext, plan: ArchitecturePlan, options?: MakeOptions): Promise<MakeResult>;
+export declare function runMake(ctx: ProjectContext, planned: ArchitecturePlan, options?: MakeOptions): Promise<MakeResult>;
 /** The plan's `package` steps as instructions — ai:make never installs dependencies itself. */
 export declare function packageSteps(plan: ArchitecturePlan): string[];

package/dist/make/make.js

@@ -6,6 +6,7 @@ import { join } from 'node:path';
 import { unifiedDiff } from './diff.js';
 import { domainFields, injectPrismaFields, injectZodFields } from './fields.js';
 import { assertSafePlan } from '../plan/identifiers.js';
+import { withGeneratorEntities } from '../plan/plan.js';
 import { externalRelationTargets, injectPrismaRelations, inverseRelationLines, relationFieldLines, relationForeignKeys, } from './relations.js';
 import { injectOpenApiMeta } from './openapi.js';
 import { renderPermissionsFile } from './permissions.js';
@@ -22,7 +23,9 @@ import { injectAuditPlugin, injectAuditService, injectPermissionGuards } from '.
  * decided. No destructive operations — never overwrites without `force`, never
  * touches the database, never deletes.
  */
-export async function runMake(ctx, plan, options = {}) {
+export async function runMake(ctx, planned, options = {}) {
+    // Generator steps whose entity the model left out still get built.
+    const plan = withGeneratorEntities(planned, ctx);
     // The plan is untrusted (LLM / MCP client): refuse any name that could
     // inject code into the generated sources before generating anything.
     assertSafePlan(plan);

package/dist/plan/knowledge.js

@@ -53,4 +53,6 @@ For generator steps, put the exact command in "command" (e.g. "basalt make:resou
 
 ENUMS: a field with a fixed set of values (a status/state) MUST set "enum" to those values — e.g. "estado (pago/pendente)" → { "name": "estado", "type": "String", "enum": ["pago", "pendente"] }. It becomes a validated z.enum([...]) (stored as a String column), never a free z.string().
 
+ENTITIES vs GENERATOR STEPS: every resource a "generator" step scaffolds MUST also be listed in "entities" with its fields — including when its Prisma model already exists (copy the existing fields). ai:make builds from "entities".
+
 RELATIONS: express a belongs-to as an entry in "relations" (e.g. an Appointment belongs to a Patient → { "name": "patient", "model": "Patient" }). Do NOT also add the "<name>Id" field to "fields" — the FK column, the @relation and the inverse field are generated. Prefer generating both sides of a relation in the same plan.`;

package/dist/plan/plan.d.ts

@@ -18,3 +18,13 @@ export interface CreatePlanOptions {
 export declare function createPlan(provider: AIProvider, ctx: ProjectContext, request: string, options?: CreatePlanOptions): Promise<ArchitecturePlan>;
 /** Parse + normalize the model's JSON into a validated plan. Tolerant of fences and missing arrays. */
 export declare function parsePlan(raw: string, request: string): ArchitecturePlan;
+/** Resource names a `basalt make:resource <Name>` generator step scaffolds. */
+export declare function generatorTargets(plan: ArchitecturePlan): string[];
+/**
+ * The plan with an entity for every generator step. Models sometimes leave
+ * `entities` empty when the Prisma models already exist and only list
+ * `make:resource` steps — ai:make then had nothing to build. A missing entity is
+ * taken from the existing model (scalar and enum columns; relations and lists
+ * are left to the schema), or created bare when there is none.
+ */
+export declare function withGeneratorEntities(plan: ArchitecturePlan, ctx: ProjectContext): ArchitecturePlan;

package/dist/plan/plan.js

@@ -160,3 +160,41 @@ function normalizeKind(value) {
         ? value
         : 'other';
 }
+/** Resource names a `basalt make:resource <Name>` generator step scaffolds. */
+export function generatorTargets(plan) {
+    const names = [];
+    for (const step of plan.steps) {
+        if (step.kind !== 'generator' || !step.command)
+            continue;
+        const name = /make:resource\s+(\w+)/.exec(step.command)?.[1];
+        if (name && !names.some((n) => n.toLowerCase() === name.toLowerCase()))
+            names.push(name);
+    }
+    return names;
+}
+const PRISMA_SCALARS = new Set(['String', 'Int', 'BigInt', 'Float', 'Decimal', 'Boolean', 'DateTime', 'Json', 'Bytes']);
+/**
+ * The plan with an entity for every generator step. Models sometimes leave
+ * `entities` empty when the Prisma models already exist and only list
+ * `make:resource` steps — ai:make then had nothing to build. A missing entity is
+ * taken from the existing model (scalar and enum columns; relations and lists
+ * are left to the schema), or created bare when there is none.
+ */
+export function withGeneratorEntities(plan, ctx) {
+    const known = new Set(plan.entities.map((e) => e.name.toLowerCase()));
+    const missing = generatorTargets(plan).filter((name) => !known.has(name.toLowerCase()));
+    if (missing.length === 0)
+        return plan;
+    const models = ctx.prisma?.models ?? [];
+    const modelNames = new Set(models.map((m) => m.name));
+    const added = missing.map((name) => {
+        const model = models.find((m) => m.name.toLowerCase() === name.toLowerCase());
+        if (!model)
+            return { name, fields: [], tenantScoped: ctx.stack.tenancy };
+        const fields = (model.columns ?? [])
+            .filter((c) => !c.list && !modelNames.has(c.type))
+            .map((c) => ({ name: c.name, type: PRISMA_SCALARS.has(c.type) ? c.type : 'String' }));
+        return { name: model.name, fields, tenantScoped: model.tenantScoped };
+    });
+    return { ...plan, entities: [...plan.entities, ...added] };
+}

package/dist/plan/render.js

@@ -1,3 +1,4 @@
+import { generatorTargets } from './plan.js';
 /** Render an {@link ArchitecturePlan} in the spec's `ARCHITECTURE PLAN` style. */
 export function renderPlan(plan, io, options = {}) {
     io.log('ARCHITECTURE PLAN');
@@ -55,7 +56,7 @@ export function renderPlan(plan, io, options = {}) {
     io.log('This is a plan only — nothing was changed.');
     // ai:make only scaffolds entities: suggesting it for a plan without any
     // would end in "nothing to generate" after a confirmation prompt.
-    io.log(plan.entities.length > 0
+    io.log(plan.entities.length > 0 || generatorTargets(plan).length > 0
         ? `Next: basalt ai:make "${plan.request}" implements it.`
         : 'Nothing for ai:make to generate — the steps above are applied by hand.');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basaltkit/ai",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "engines": {
     "node": ">=22.5.0"
   },