@basaltkit/ai 0.11.0 → 1.0.0

package/dist/provider/openai.d.ts

@@ -0,0 +1,48 @@
+import { type SseFetch } from './sse.js';
+import { type AIProvider, type FetchLike, type GenerateOptions } from './types.js';
+export interface OpenAICompatibleProviderOptions {
+    /** API key → `Authorization: Bearer <key>`. Required. */
+    apiKey: string;
+    /** Model id, e.g. `'gpt-4o-mini'` or `'us.anthropic.claude-sonnet-4-5-20250929-v1:0'`. */
+    model?: string;
+    /**
+     * API base URL up to and including `/v1`. `/chat/completions` is appended.
+     * Defaults to the public OpenAI API; point it at any compatible gateway, e.g.
+     * `https://ai.go4ai.io/v1`.
+     */
+    baseUrl?: string;
+    /**
+     * Stream the completion via SSE (default `true`). Streaming avoids the spurious
+     * 500 some gateways return when buffering a long non-streaming response. Set
+     * `false` for a gateway that doesn't support streaming.
+     */
+    stream?: boolean;
+    /** Injected non-streaming fetch. Defaults to the global `fetch`. */
+    fetch?: FetchLike;
+    /** Injected streaming fetch. Defaults to one built on the global `fetch`. */
+    sseFetch?: SseFetch;
+}
+/**
+ * Provider for any OpenAI-compatible Chat Completions endpoint (OpenAI itself,
+ * Azure-style gateways, LiteLLM, OpenRouter, go4ai, …). Unlike Anthropic's API,
+ * system messages stay inline in the `messages` array.
+ *
+ * Streams by default — the robust path for large generations behind a gateway.
+ */
+export declare class OpenAICompatibleProvider implements AIProvider {
+    readonly name = "openai";
+    readonly model: string;
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly streaming;
+    private readonly fetchImpl;
+    private readonly sseFetchImpl;
+    constructor(options: OpenAICompatibleProviderOptions);
+    generate(options: GenerateOptions): Promise<string>;
+    stream(options: GenerateOptions): AsyncIterable<string>;
+    private get endpoint();
+    private headers;
+    private requestBody;
+    private viaStream;
+    private viaJson;
+}

package/dist/provider/openai.js

@@ -0,0 +1,94 @@
+import { fetchWithRetry } from './http.js';
+import { globalSseFetch, parseSseContent } from './sse.js';
+import { singleChunkStream, } from './types.js';
+const DEFAULT_MODEL = 'gpt-4o-mini';
+const DEFAULT_BASE_URL = 'https://api.openai.com/v1';
+/**
+ * Provider for any OpenAI-compatible Chat Completions endpoint (OpenAI itself,
+ * Azure-style gateways, LiteLLM, OpenRouter, go4ai, …). Unlike Anthropic's API,
+ * system messages stay inline in the `messages` array.
+ *
+ * Streams by default — the robust path for large generations behind a gateway.
+ */
+export class OpenAICompatibleProvider {
+    name = 'openai';
+    model;
+    apiKey;
+    baseUrl;
+    streaming;
+    fetchImpl;
+    sseFetchImpl;
+    constructor(options) {
+        if (!options.apiKey) {
+            throw new Error('OpenAICompatibleProvider: apiKey is required (set AI_API_KEY)');
+        }
+        this.apiKey = options.apiKey;
+        this.model = options.model ?? DEFAULT_MODEL;
+        this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, '');
+        this.streaming = options.stream ?? true;
+        this.fetchImpl = options.fetch ?? globalThis.fetch ?? missingFetch;
+        this.sseFetchImpl = options.sseFetch ?? globalSseFetch;
+    }
+    async generate(options) {
+        if (!this.streaming)
+            return this.viaJson(options);
+        let out = '';
+        for await (const delta of this.viaStream(options))
+            out += delta;
+        return out;
+    }
+    stream(options) {
+        if (!this.streaming)
+            return singleChunkStream(() => this.viaJson(options));
+        return this.viaStream(options);
+    }
+    get endpoint() {
+        return this.baseUrl + '/chat/completions';
+    }
+    headers() {
+        return { 'content-type': 'application/json', authorization: `Bearer ${this.apiKey}` };
+    }
+    requestBody(options, stream) {
+        return JSON.stringify({
+            model: this.model,
+            messages: options.messages.map((m) => ({ role: m.role, content: m.content })),
+            max_tokens: options.maxTokens ?? 4096,
+            ...(options.temperature !== undefined ? { temperature: options.temperature } : {}),
+            ...(stream ? { stream: true } : {}),
+        });
+    }
+    async *viaStream(options) {
+        const res = await this.sseFetchImpl(this.endpoint, {
+            method: 'POST',
+            headers: this.headers(),
+            body: this.requestBody(options, true),
+        });
+        if (!res.ok) {
+            throw new Error(`OpenAICompatibleProvider: ${res.status} — ${safeError(await res.text())}`);
+        }
+        yield* parseSseContent(res.chunks);
+    }
+    async viaJson(options) {
+        const { ok, status, body } = await fetchWithRetry(this.fetchImpl, this.endpoint, {
+            method: 'POST',
+            headers: this.headers(),
+            body: this.requestBody(options, false),
+        });
+        if (!ok) {
+            const detail = safeError(body);
+            throw new Error(`OpenAICompatibleProvider: ${status}${detail ? ` — ${detail}` : ''}`);
+        }
+        return JSON.parse(body).choices?.[0]?.message?.content ?? '';
+    }
+}
+const missingFetch = () => {
+    throw new Error('OpenAICompatibleProvider: no fetch available — pass options.fetch');
+};
+function safeError(text) {
+    try {
+        return JSON.parse(text).error?.message ?? text.slice(0, 200);
+    }
+    catch {
+        return text.slice(0, 200);
+    }
+}

package/dist/provider/sse.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Minimal Server-Sent-Events support for OpenAI-compatible streaming.
+ *
+ * Some gateways (e.g. go4ai) return a spurious 500 when they buffer a long
+ * non-streaming completion, even though the model generated it (and charged for
+ * it). Streaming sidesteps that: the response is delivered in chunks, so there's
+ * no large buffered body to choke on.
+ */
+export interface SseResponse {
+    ok: boolean;
+    status: number;
+    /** Full body — used for the error message on a non-2xx. */
+    text(): Promise<string>;
+    /** Decoded text pieces of the streaming body. */
+    chunks: AsyncIterable<string>;
+}
+export type SseFetch = (url: string, init: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+}) => Promise<SseResponse>;
+/** Default {@link SseFetch} backed by the global `fetch` + its streaming body. */
+export declare const globalSseFetch: SseFetch;
+/**
+ * Parse an OpenAI-style SSE stream, yielding each `choices[0].delta.content`
+ * piece. Tolerant of keep-alive lines, partial frames and the `[DONE]` sentinel.
+ */
+export declare function parseSseContent(chunks: AsyncIterable<string>): AsyncIterable<string>;

package/dist/provider/sse.js

@@ -0,0 +1,57 @@
+/**
+ * Minimal Server-Sent-Events support for OpenAI-compatible streaming.
+ *
+ * Some gateways (e.g. go4ai) return a spurious 500 when they buffer a long
+ * non-streaming completion, even though the model generated it (and charged for
+ * it). Streaming sidesteps that: the response is delivered in chunks, so there's
+ * no large buffered body to choke on.
+ */
+/** Default {@link SseFetch} backed by the global `fetch` + its streaming body. */
+export const globalSseFetch = async (url, init) => {
+    const f = globalThis.fetch;
+    if (!f)
+        throw new Error('globalSseFetch: no global fetch available');
+    const res = (await f(url, {
+        method: init.method,
+        headers: init.headers,
+        body: init.body,
+    }));
+    const stream = res.body;
+    const decoder = new TextDecoder();
+    async function* chunks() {
+        if (!stream)
+            return;
+        for await (const part of stream)
+            yield decoder.decode(part, { stream: true });
+    }
+    return { ok: res.ok, status: res.status, text: () => res.text(), chunks: chunks() };
+};
+/**
+ * Parse an OpenAI-style SSE stream, yielding each `choices[0].delta.content`
+ * piece. Tolerant of keep-alive lines, partial frames and the `[DONE]` sentinel.
+ */
+export async function* parseSseContent(chunks) {
+    let buffer = '';
+    for await (const chunk of chunks) {
+        buffer += chunk;
+        const lines = buffer.split('\n');
+        buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith('data:'))
+                continue;
+            const payload = trimmed.slice(5).trim();
+            if (payload === '' || payload === '[DONE]')
+                continue;
+            try {
+                const delta = JSON.parse(payload).choices?.[0]
+                    ?.delta?.content;
+                if (delta)
+                    yield delta;
+            }
+            catch {
+                // keep-alive or split frame — ignore and continue
+            }
+        }
+    }
+}

package/dist/provider/types.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Provider-agnostic AI surface.
+ *
+ * The agent never talks to a vendor SDK directly — every piece of it depends on
+ * this interface. Swapping Anthropic ↔ Ollama ↔ an OpenAI-compatible endpoint is
+ * therefore an `AI_PROVIDER` config change, not a code change (spec §17).
+ */
+export interface AIMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+export interface GenerateOptions {
+    messages: AIMessage[];
+    /** Sampling temperature (0 = deterministic). */
+    temperature?: number;
+    /** Hard cap on output tokens. */
+    maxTokens?: number;
+}
+export interface AIProvider {
+    /** Stable id, e.g. `'anthropic'`. */
+    readonly name: string;
+    /** Concrete model id in use, e.g. `'claude-sonnet-5'`. */
+    readonly model: string;
+    /** One-shot completion — returns the assistant's full text. */
+    generate(options: GenerateOptions): Promise<string>;
+    /** Streaming completion — yields chunks as they arrive. */
+    stream(options: GenerateOptions): AsyncIterable<string>;
+}
+/**
+ * Minimal fetch surface — the global `fetch` (Node 18+) is assignable, and it's
+ * injectable so providers can be unit-tested without a network. Mirrors the shape
+ * used by `@basaltkit/search-elasticsearch` to avoid a DOM lib dependency.
+ */
+export type FetchLike = (url: string, init?: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    text(): Promise<string>;
+}>;
+/**
+ * Default `stream()` implementation for providers without real token streaming
+ * yet: run the one-shot completion and yield it as a single chunk. Real
+ * server-sent-event streaming lands in a later phase; this keeps the
+ * {@link AIProvider} contract honest today.
+ */
+export declare function singleChunkStream(run: () => Promise<string>): AsyncIterable<string>;

package/dist/provider/types.js

@@ -0,0 +1,9 @@
+/**
+ * Default `stream()` implementation for providers without real token streaming
+ * yet: run the one-shot completion and yield it as a single chunk. Real
+ * server-sent-event streaming lands in a later phase; this keeps the
+ * {@link AIProvider} contract honest today.
+ */
+export async function* singleChunkStream(run) {
+    yield await run();
+}

package/dist/render.d.ts

@@ -0,0 +1,10 @@
+import type { AnalysisReport } from './analyze/run.js';
+import type { Diagnostic } from './doctor/types.js';
+/** The single output method the CLI needs — matches `CommandIo.log`. */
+export interface LineWriter {
+    log(message: string): void;
+}
+/** Render the `ai:analyze` report in the spec's `✓ … detected` style. */
+export declare function renderAnalysis(report: AnalysisReport, io: LineWriter): void;
+/** Render the `ai:doctor` diagnostics in the spec's `AI DIAGNOSTICS` style. */
+export declare function renderDoctor(diagnostics: Diagnostic[], io: LineWriter): void;

package/dist/render.js

@@ -0,0 +1,70 @@
+const MARK = { error: '✗', warning: '⚠', info: 'ℹ' };
+/** Render the `ai:analyze` report in the spec's `✓ … detected` style. */
+export function renderAnalysis(report, io) {
+    io.log('Analyzing project...');
+    io.log('');
+    if (report.capabilities.length === 0) {
+        io.log('  No Basalt capabilities detected — is this a Basalt app? (looked for src/app.ts)');
+    }
+    else {
+        for (const line of report.capabilities)
+            io.log(`✓ ${line}`);
+    }
+    if (report.models.length > 0) {
+        io.log('');
+        io.log(`Data model (${report.models.length} model${report.models.length === 1 ? '' : 's'}):`);
+        for (const name of report.models) {
+            const scoped = report.tenantScopedModels.includes(name);
+            io.log(`  • ${name}${scoped ? '  (tenant-scoped)' : ''}`);
+        }
+    }
+    io.log('');
+    if (report.diagnostics.length === 0) {
+        io.log('✓ No issues found.');
+    }
+    else {
+        const errors = report.diagnostics.filter((d) => d.severity === 'error').length;
+        const warnings = report.diagnostics.filter((d) => d.severity === 'warning').length;
+        const infos = report.diagnostics.filter((d) => d.severity === 'info').length;
+        io.log(`Diagnostics: ${errors} error(s), ${warnings} warning(s), ${infos} info.`);
+        io.log('Run `basalt ai:doctor` for details and fixes.');
+    }
+}
+/** Render the `ai:doctor` diagnostics in the spec's `AI DIAGNOSTICS` style. */
+export function renderDoctor(diagnostics, io) {
+    io.log('AI DIAGNOSTICS');
+    io.log('');
+    if (diagnostics.length === 0) {
+        io.log('✓ Everything looks healthy.');
+        return;
+    }
+    for (const d of diagnostics) {
+        io.log(`${MARK[d.severity]} ${d.title}  [${d.category}]`);
+        io.log('');
+        io.log('  Detected:');
+        io.log(`    ${d.detected}`);
+        io.log('');
+        io.log('  Recommended:');
+        io.log(`    ${d.recommended}`);
+        io.log('');
+        io.log('  Reason:');
+        io.log(`    ${d.reason}`);
+        if (d.fix) {
+            io.log('');
+            io.log('  Fix:');
+            for (const line of d.fix.split('\n'))
+                io.log(`    ${line}`);
+        }
+        if (d.docs) {
+            io.log('');
+            io.log(`  Docs: https://basaltkit.dev${d.docs}`);
+        }
+        io.log('');
+        io.log('  ' + '─'.repeat(60));
+        io.log('');
+    }
+    const errors = diagnostics.filter((d) => d.severity === 'error').length;
+    const warnings = diagnostics.filter((d) => d.severity === 'warning').length;
+    io.log(`${diagnostics.length} finding(s): ${errors} error(s), ${warnings} warning(s), ` +
+        `${diagnostics.length - errors - warnings} info.`);
+}

package/dist/review/knowledge.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The Review agent's rubric (spec §20). It reviews the *generated code* against
+ * Basalt's conventions and the original request, and returns issues by dimension.
+ * It does not rewrite code — it judges it.
+ */
+export declare const REVIEW_KNOWLEDGE = "You are the Review agent for Basalt, a SaaS framework (Fastify + Prisma + Zod). Given a feature request, its plan, the deterministic review results and the generated code, decide whether the implementation is correct and on-convention. You do NOT rewrite code \u2014 you review it, precisely.\n\nSCOPE: `ai:make` generates a BACKEND resource vertical only \u2014 Prisma model, Zod schema, typed routes, service, repository, permissions and a test. It does NOT generate web/UI, React, frontend pages, background jobs, emails or infrastructure; other tools do. Review ONLY the backend vertical, on its own terms. If the request also asks for something outside this scope (a web page, a component, a job\u2026), mention it as a \"warning\" at most \u2014 NEVER an \"error\" \u2014 since `ai:make` is not the tool that produces it.\n\nCheck these dimensions and only raise an issue you can point to in the code:\n\n- tenancy: a tenant-scoped model MUST carry a tenantId column, and every query in its repository MUST be scoped by tenantId (create stamps it; list/find/update/delete filter by it). Raise an ERROR if a tenant-scoped resource can leak or write across tenants.\n- security: no hardcoded secrets; request bodies validated by Zod; no obvious injection.\n- rbac: routes carry `meta: { can: '<resource>.<action>' }` guards, and the permissions are declared. ERROR if a mutating route is unguarded when RBAC is enabled.\n- validation: every route has a Zod schema; the repository maps Prisma rows to the API type (no Date leaking as a Date, no raw row returned).\n- audit: state changes record audit events when audit is enabled (warning if not).\n- tests: a test file exists.\n- fit: the generated backend matches the request's DATA MODEL \u2014 the right entities, fields, relations and tenancy. Do NOT raise an \"error\" for artifacts outside the backend vertical (web UI, frontend, jobs); those are out of scope.\n\nReturn ONLY a single JSON object (no prose, no markdown fences):\n{\n  \"summary\": string,                       // one or two sentences\n  \"issues\": [ { \"dimension\": string, \"severity\": \"error\" | \"warning\", \"message\": string } ]\n}\nRaise \"error\" only for a real, blocking convention violation you can cite; use \"warning\" for improvements. An empty issues array means the implementation is approved.";

package/dist/review/knowledge.js

@@ -0,0 +1,25 @@
+/**
+ * The Review agent's rubric (spec §20). It reviews the *generated code* against
+ * Basalt's conventions and the original request, and returns issues by dimension.
+ * It does not rewrite code — it judges it.
+ */
+export const REVIEW_KNOWLEDGE = `You are the Review agent for Basalt, a SaaS framework (Fastify + Prisma + Zod). Given a feature request, its plan, the deterministic review results and the generated code, decide whether the implementation is correct and on-convention. You do NOT rewrite code — you review it, precisely.
+
+SCOPE: \`ai:make\` generates a BACKEND resource vertical only — Prisma model, Zod schema, typed routes, service, repository, permissions and a test. It does NOT generate web/UI, React, frontend pages, background jobs, emails or infrastructure; other tools do. Review ONLY the backend vertical, on its own terms. If the request also asks for something outside this scope (a web page, a component, a job…), mention it as a "warning" at most — NEVER an "error" — since \`ai:make\` is not the tool that produces it.
+
+Check these dimensions and only raise an issue you can point to in the code:
+
+- tenancy: a tenant-scoped model MUST carry a tenantId column, and every query in its repository MUST be scoped by tenantId (create stamps it; list/find/update/delete filter by it). Raise an ERROR if a tenant-scoped resource can leak or write across tenants.
+- security: no hardcoded secrets; request bodies validated by Zod; no obvious injection.
+- rbac: routes carry \`meta: { can: '<resource>.<action>' }\` guards, and the permissions are declared. ERROR if a mutating route is unguarded when RBAC is enabled.
+- validation: every route has a Zod schema; the repository maps Prisma rows to the API type (no Date leaking as a Date, no raw row returned).
+- audit: state changes record audit events when audit is enabled (warning if not).
+- tests: a test file exists.
+- fit: the generated backend matches the request's DATA MODEL — the right entities, fields, relations and tenancy. Do NOT raise an "error" for artifacts outside the backend vertical (web UI, frontend, jobs); those are out of scope.
+
+Return ONLY a single JSON object (no prose, no markdown fences):
+{
+  "summary": string,                       // one or two sentences
+  "issues": [ { "dimension": string, "severity": "error" | "warning", "message": string } ]
+}
+Raise "error" only for a real, blocking convention violation you can cite; use "warning" for improvements. An empty issues array means the implementation is approved.`;

package/dist/review/render.d.ts

@@ -0,0 +1,4 @@
+import type { LineWriter } from '../render.js';
+import type { AgentReview } from './types.js';
+/** Render the Review agent's verdict in the spec's `Implementation rejected` style. */
+export declare function renderAgentReview(review: AgentReview, io: LineWriter): void;

package/dist/review/render.js

@@ -0,0 +1,12 @@
+/** Render the Review agent's verdict in the spec's `Implementation rejected` style. */
+export function renderAgentReview(review, io) {
+    io.log(review.approved ? '✓ Review agent: approved' : '✗ Review agent: changes requested');
+    if (review.summary)
+        io.log(`  ${review.summary}`);
+    if (review.issues.length > 0) {
+        io.log('  Issues:');
+        for (const issue of review.issues) {
+            io.log(`    ${issue.severity === 'error' ? '✗' : '⚠'} [${issue.dimension}] ${issue.message}`);
+        }
+    }
+}

package/dist/review/review.d.ts

@@ -0,0 +1,17 @@
+import type { MakeResult } from '../make/types.js';
+import type { ArchitecturePlan } from '../plan/types.js';
+import type { AIProvider } from '../provider/types.js';
+import type { AgentReview } from './types.js';
+export interface ReviewOptions {
+    temperature?: number;
+    maxTokens?: number;
+}
+/**
+ * Compact, relevant-only context for the Review agent: the request, the plan, the
+ * deterministic review, and the generated code that carries behaviour.
+ */
+export declare function buildReviewContext(plan: ArchitecturePlan, result: MakeResult): string;
+/** Ask the Review agent to critique the generated code. Read-only — it judges, it doesn't edit. */
+export declare function reviewImplementation(provider: AIProvider, plan: ArchitecturePlan, result: MakeResult, options?: ReviewOptions): Promise<AgentReview>;
+/** Parse the verdict. `approved` is derived from the issues, not trusted from the model. */
+export declare function parseReview(raw: string): AgentReview;

package/dist/review/review.js

@@ -0,0 +1,80 @@
+import { REVIEW_KNOWLEDGE } from './knowledge.js';
+/** Files worth sending to the reviewer — the ones that carry the behaviour. */
+const REVIEWABLE = /\.prisma$|\.(schema|routes|service|repository|permissions)\.ts$/;
+/**
+ * Compact, relevant-only context for the Review agent: the request, the plan, the
+ * deterministic review, and the generated code that carries behaviour.
+ */
+export function buildReviewContext(plan, result) {
+    const lines = [
+        `REQUEST: ${plan.request}`,
+        '',
+        'PLAN:',
+        `  summary: ${plan.summary}`,
+        `  entities: ${plan.entities.map((e) => `${e.name}${e.tenantScoped ? ' (tenant-scoped)' : ''}`).join(', ')}`,
+    ];
+    if (plan.permissions.length > 0)
+        lines.push(`  permissions: ${plan.permissions.join(', ')}`);
+    if (plan.auditEvents.length > 0)
+        lines.push(`  auditEvents: ${plan.auditEvents.join(', ')}`);
+    lines.push('', 'DETERMINISTIC REVIEW:');
+    for (const item of result.review.items)
+        lines.push(`  [${item.status}] ${item.label}: ${item.detail}`);
+    lines.push('', 'GENERATED CODE:');
+    for (const resource of result.resources) {
+        for (const file of resource.files) {
+            if (REVIEWABLE.test(file.path))
+                lines.push(`--- ${file.path} ---`, file.content);
+        }
+    }
+    return lines.join('\n');
+}
+/** Ask the Review agent to critique the generated code. Read-only — it judges, it doesn't edit. */
+export async function reviewImplementation(provider, plan, result, options = {}) {
+    const raw = await provider.generate({
+        messages: [
+            { role: 'system', content: REVIEW_KNOWLEDGE },
+            { role: 'user', content: `${buildReviewContext(plan, result)}\n\nReturn the verdict as a single JSON object.` },
+        ],
+        temperature: options.temperature ?? 0,
+        maxTokens: options.maxTokens ?? 2048,
+    });
+    return parseReview(raw);
+}
+/** Parse the verdict. `approved` is derived from the issues, not trusted from the model. */
+export function parseReview(raw) {
+    const json = extractJson(raw);
+    let obj;
+    try {
+        obj = JSON.parse(json);
+    }
+    catch {
+        throw new Error(`ai review — the model did not return valid JSON. Got: ${raw.slice(0, 160)}…`);
+    }
+    const issues = normalizeIssues(obj['issues']);
+    return {
+        approved: !issues.some((i) => i.severity === 'error'),
+        summary: typeof obj['summary'] === 'string' ? obj['summary'] : '',
+        issues,
+    };
+}
+function normalizeIssues(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .filter((i) => typeof i === 'object' && i !== null)
+        .map((i) => ({
+        dimension: typeof i['dimension'] === 'string' ? i['dimension'] : 'general',
+        severity: i['severity'] === 'error' ? 'error' : 'warning',
+        message: typeof i['message'] === 'string' ? i['message'] : '',
+    }))
+        .filter((i) => i.message !== '');
+}
+function extractJson(raw) {
+    const withoutFence = raw.replace(/```(?:json)?/gi, '').trim();
+    const start = withoutFence.indexOf('{');
+    const end = withoutFence.lastIndexOf('}');
+    if (start === -1 || end === -1 || end < start)
+        return withoutFence;
+    return withoutFence.slice(start, end + 1);
+}

package/dist/review/types.d.ts

@@ -0,0 +1,12 @@
+export interface ReviewIssue {
+    /** e.g. `tenancy`, `security`, `rbac`, `validation`, `tests`, `fit`. */
+    dimension: string;
+    severity: 'error' | 'warning';
+    message: string;
+}
+export interface AgentReview {
+    /** Derived: true only when no issue is error-severity. */
+    approved: boolean;
+    summary: string;
+    issues: ReviewIssue[];
+}

package/dist/review/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basaltkit/ai",
-  "version": "0.11.0",
+  "version": "1.0.0",
   "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",
@@ -14,14 +14,13 @@
     "dist"
   ],
   "dependencies": {
-    "@basaltkit/cli": "^1.2.0",
-    "@basaltkit/generator": "^1.1.1"
+    "@basaltkit/generator": "^1.1.1",
+    "@basaltkit/cli": "^1.2.0"
   },
   "devDependencies": {
-    "@types/node": "^22.15.0",
-    "tsup": "^8.4.0",
-    "typescript": "^5.8.0",
-    "vitest": "^3.1.0",
+    "@types/node": "^26.3.0",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.11",
     "@basaltkit/tsconfig": "^0.24.0"
   },
   "publishConfig": {
@@ -29,11 +28,11 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Zebedeu/basalt.git",
+    "url": "git+https://github.com/basaltkit/basalt.git",
     "directory": "packages/ai"
   },
-  "homepage": "https://github.com/Zebedeu/basalt/tree/main/packages/ai#readme",
-  "bugs": "https://github.com/Zebedeu/basalt/issues",
+  "homepage": "https://github.com/basaltkit/basalt/tree/main/packages/ai#readme",
+  "bugs": "https://github.com/basaltkit/basalt/issues",
   "keywords": [
     "basalt",
     "ai",
@@ -43,7 +42,7 @@
     "typescript"
   ],
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean",
+    "build": "tsc -p tsconfig.build.json",
     "test": "vitest run",
     "typecheck": "tsc --noEmit"
   }