@basaltkit/ai 1.0.1 → 1.1.1

package/dist/schema/index.js

@@ -0,0 +1,228 @@
+/**
+ * Runtime schemas for the AI layer's public data contracts. `@basaltkit/ai` is a
+ * dev-only package, so taking a `zod` dependency here is acceptable — these
+ * schemas exist so out-of-process consumers (notably the forthcoming dev-only
+ * `@basaltkit/ai-mcp` bridge) can (a) validate tool inputs/outputs and (b) derive
+ * JSON Schema to advertise as MCP `inputSchema`/`outputSchema`.
+ *
+ * The schemas mirror the exported TypeScript interfaces exactly. `parsePlan` and
+ * `parseReview` route their already-coerced output through them (validate *after*
+ * tolerant coercion — the model's raw text is never fed to `.parse()` directly).
+ */
+import { z } from 'zod';
+/** Bump when the serialized shape of a plan changes incompatibly. */
+export const PLAN_SCHEMA_VERSION = 1;
+/** Bump when the serialized shape of a make result changes incompatibly. */
+export const MAKE_SCHEMA_VERSION = 1;
+// --- Provider-agnostic scalars ---------------------------------------------
+const DatabaseSchema = z.enum(['postgresql', 'mysql', 'sqlite']).nullable();
+// --- ProjectContext (context/project.ts) -----------------------------------
+export const DetectedStackSchema = z.object({
+    http: z.enum(['fastify']).nullable(),
+    orm: z.enum(['prisma']).nullable(),
+    database: DatabaseSchema,
+    tenancy: z.boolean(),
+    auth: z.boolean(),
+    rbac: z.boolean(),
+    subscriptions: z.boolean(),
+    payments: z.boolean(),
+    storage: z.boolean(),
+    queue: z.boolean(),
+    search: z.boolean(),
+    audit: z.boolean(),
+    events: z.boolean(),
+    scheduler: z.boolean(),
+    logger: z.boolean(),
+    ai: z.boolean(),
+});
+export const PrismaModelSchema = z.object({
+    name: z.string(),
+    fields: z.array(z.string()),
+    tenantScoped: z.boolean(),
+});
+export const PrismaInfoSchema = z.object({
+    provider: DatabaseSchema,
+    models: z.array(PrismaModelSchema),
+});
+export const AppFileInfoSchema = z.object({
+    path: z.string(),
+    plugins: z.array(z.string()),
+    fastifyLoggerConfigured: z.boolean(),
+    memorySources: z.array(z.string()),
+    pluginCalls: z.array(z.string()),
+});
+export const ServerFileInfoSchema = z.object({
+    path: z.string(),
+    connectsAtBoot: z.boolean(),
+    startsServer: z.boolean(),
+});
+export const EnvFileInfoSchema = z.object({
+    path: z.string(),
+    appSecretDefault: z.string().nullable(),
+    redisUrlDefault: z.string().nullable(),
+});
+export const ProjectContextSchema = z.object({
+    root: z.string(),
+    installed: z.array(z.string()),
+    stack: DetectedStackSchema,
+    prisma: PrismaInfoSchema.nullable(),
+    app: AppFileInfoSchema.nullable(),
+    server: ServerFileInfoSchema.nullable(),
+    env: EnvFileInfoSchema.nullable(),
+});
+// --- Diagnostics + AnalysisReport (doctor/types.ts, analyze/run.ts) --------
+export const SeveritySchema = z.enum(['error', 'warning', 'info']);
+export const DiagnosticCategorySchema = z.enum([
+    'security',
+    'database',
+    'observability',
+    'tenancy',
+    'performance',
+    'durability',
+    'config',
+]);
+export const DiagnosticSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    severity: SeveritySchema,
+    category: DiagnosticCategorySchema,
+    detected: z.string(),
+    recommended: z.string(),
+    reason: z.string(),
+    fix: z.string().optional(),
+    docs: z.string().optional(),
+});
+export const AnalysisReportSchema = z.object({
+    root: z.string(),
+    capabilities: z.array(z.string()),
+    installed: z.array(z.string()),
+    database: z.string().nullable(),
+    models: z.array(z.string()),
+    tenantScopedModels: z.array(z.string()),
+    unscopedModels: z.array(z.string()),
+    diagnostics: z.array(DiagnosticSchema),
+});
+// --- ArchitecturePlan (plan/types.ts) --------------------------------------
+export const PlanFieldSchema = z.object({
+    name: z.string(),
+    type: z.string(),
+    enum: z.array(z.string()).optional(),
+});
+export const PlanRelationSchema = z.object({
+    name: z.string(),
+    model: z.string(),
+});
+export const PlanEntitySchema = z.object({
+    name: z.string(),
+    fields: z.array(PlanFieldSchema),
+    tenantScoped: z.boolean(),
+    relations: z.array(PlanRelationSchema).optional(),
+});
+export const PlanStepKindSchema = z.enum([
+    'generator',
+    'schema',
+    'migration',
+    'service',
+    'routes',
+    'permissions',
+    'audit',
+    'test',
+    'docs',
+    'other',
+]);
+export const PlanStepSchema = z.object({
+    order: z.number(),
+    title: z.string(),
+    kind: PlanStepKindSchema,
+    detail: z.string(),
+    command: z.string().optional(),
+    files: z.array(z.string()).optional(),
+});
+export const ArchitecturePlanSchema = z.object({
+    schemaVersion: z.number().int().default(PLAN_SCHEMA_VERSION),
+    request: z.string(),
+    summary: z.string(),
+    entities: z.array(PlanEntitySchema),
+    steps: z.array(PlanStepSchema),
+    permissions: z.array(z.string()),
+    auditEvents: z.array(z.string()),
+    tenantScoped: z.boolean(),
+    warnings: z.array(z.string()),
+});
+// --- MakeResult (make/types.ts) --------------------------------------------
+export const GeneratedFileSchema = z.object({
+    path: z.string(),
+    content: z.string(),
+});
+export const SchemaMergeSchema = z.object({
+    path: z.string(),
+    found: z.boolean(),
+    merged: z.array(z.string()),
+    skipped: z.array(z.string()),
+    written: z.boolean(),
+});
+export const MigrationSchema = z.object({
+    ok: z.boolean(),
+    output: z.string(),
+});
+export const ResourceBuildSchema = z.object({
+    name: z.string(),
+    prisma: z.boolean(),
+    softDelete: z.boolean(),
+    files: z.array(GeneratedFileSchema),
+    augmented: z.boolean(),
+    guarded: z.boolean(),
+    audited: z.boolean(),
+    written: z.array(z.string()),
+    registered: z.boolean(),
+    note: z.string().optional(),
+});
+export const ReviewStatusSchema = z.enum(['pass', 'warn', 'fail']);
+export const ReviewItemSchema = z.object({
+    label: z.string(),
+    status: ReviewStatusSchema,
+    detail: z.string(),
+});
+export const ReviewResultSchema = z.object({
+    items: z.array(ReviewItemSchema),
+    ok: z.boolean(),
+});
+export const FilePreviewSchema = z.object({
+    path: z.string(),
+    action: z.enum(['create', 'overwrite']),
+    diff: z.string(),
+});
+export const MakePreviewSchema = z.object({
+    perFile: z.array(FilePreviewSchema),
+    clashes: z.array(z.string()),
+});
+export const MakeResultSchema = z.object({
+    schemaVersion: z.number().int().default(MAKE_SCHEMA_VERSION),
+    request: z.string(),
+    dryRun: z.boolean(),
+    resources: z.array(ResourceBuildSchema),
+    schema: SchemaMergeSchema.optional(),
+    migration: MigrationSchema.optional(),
+    followUps: z.array(z.string()),
+    review: ReviewResultSchema,
+    preview: MakePreviewSchema.optional(),
+});
+// --- AgentReview (review/types.ts) -----------------------------------------
+export const ReviewIssueSchema = z.object({
+    dimension: z.string(),
+    severity: z.enum(['error', 'warning']),
+    message: z.string(),
+});
+export const AgentReviewSchema = z.object({
+    approved: z.boolean(),
+    summary: z.string(),
+    issues: z.array(ReviewIssueSchema),
+});
+// --- JSON Schema derivation -------------------------------------------------
+/**
+ * Convert one of the exported zod schemas to JSON Schema (Draft 2020-12), for an
+ * out-of-process consumer to advertise as an MCP tool `inputSchema`/`outputSchema`.
+ */
+export function toJsonSchema(schema) {
+    return z.toJSONSchema(schema);
+}

package/dist/workflows.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Framework-free provider-backed workflow surface: the AI provider factory and
+ * the plan/review workflow steps — WITHOUT the `basalt ai` CLI wiring, which
+ * imports `@basaltkit/cli` (→ `@basaltkit/core`). Sibling to `@basaltkit/ai/analysis`.
+ *
+ * It exists so out-of-process, dev-only consumers — notably `@basaltkit/ai-mcp` —
+ * can build a provider and run plan/review without pulling `@basaltkit/core` or
+ * `@basaltkit/http` into their dependency graph. Everything here is also exported
+ * from the main barrel; this is a boundary-preserving subset, not a new API.
+ */
+export { createProvider, providerEnvFrom, providerEnvFromProcess, type CreateProviderOptions, type ProviderEnv, type ProviderName, } from './provider/factory.js';
+export { type AIMessage, type AIProvider, type FetchLike, type GenerateOptions, } from './provider/types.js';
+export { type OnProgress, type WorkflowProgress, type WorkflowRunOptions } from './generate.js';
+export { createPlan, parsePlan, type CreatePlanOptions } from './plan/plan.js';
+export type { ArchitecturePlan, PlanEntity, PlanField, PlanRelation, PlanStep, PlanStepKind, } from './plan/types.js';
+export { buildReviewContext, parseReview, reviewImplementation, type ReviewOptions, } from './review/review.js';
+export type { AgentReview, ReviewIssue } from './review/types.js';
+export { runMake } from './make/make.js';
+export type { MakeOptions, MakeResult, MakePreview, FilePreview, ResourceBuild, SchemaMerge, Migration, ReviewResult, ReviewItem, ReviewStatus, } from './make/types.js';

package/dist/workflows.js

@@ -0,0 +1,23 @@
+/**
+ * Framework-free provider-backed workflow surface: the AI provider factory and
+ * the plan/review workflow steps — WITHOUT the `basalt ai` CLI wiring, which
+ * imports `@basaltkit/cli` (→ `@basaltkit/core`). Sibling to `@basaltkit/ai/analysis`.
+ *
+ * It exists so out-of-process, dev-only consumers — notably `@basaltkit/ai-mcp` —
+ * can build a provider and run plan/review without pulling `@basaltkit/core` or
+ * `@basaltkit/http` into their dependency graph. Everything here is also exported
+ * from the main barrel; this is a boundary-preserving subset, not a new API.
+ */
+// Provider factory + the vendor-agnostic surface.
+export { createProvider, providerEnvFrom, providerEnvFromProcess, } from './provider/factory.js';
+export {} from './provider/types.js';
+// Progress + cancellation vocabulary.
+export {} from './generate.js';
+// Planning.
+export { createPlan, parsePlan } from './plan/plan.js';
+// Review — LLM critique of a build result.
+export { buildReviewContext, parseReview, reviewImplementation, } from './review/review.js';
+// Implementation — execute a plan (scaffold + review gate). Safe by default:
+// dry-run detects clashes and attaches diffs; writes never touch the DB unless
+// `migrate` is set. Framework-free via `@basaltkit/generator/resource`.
+export { runMake } from './make/make.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basaltkit/ai",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "AI-native developer experience for Basalt: a provider-agnostic engine plus `basalt ai` CLI that understands the project's stack, analyzes it, and diagnoses issues — following the framework's own conventions, not inventing new ones.",
   "license": "MIT",
   "type": "module",
@@ -8,14 +8,27 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./schema": {
+      "types": "./dist/schema/index.d.ts",
+      "import": "./dist/schema/index.js"
+    },
+    "./analysis": {
+      "types": "./dist/analysis.d.ts",
+      "import": "./dist/analysis.js"
+    },
+    "./workflows": {
+      "types": "./dist/workflows.d.ts",
+      "import": "./dist/workflows.js"
     }
   },
   "files": [
     "dist"
   ],
   "dependencies": {
-    "@basaltkit/cli": "^1.2.1",
-    "@basaltkit/generator": "^1.1.2"
+    "zod": "^4.0.0",
+    "@basaltkit/cli": "^1.2.2",
+    "@basaltkit/generator": "^1.2.1"
   },
   "devDependencies": {
     "@types/node": "^26.3.0",