@agentic-kit/db-tools 0.2.0

package/tools/run-codegen.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prewarmAppWorkspace = exports.runCodegenTool = void 0;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const zod_1 = require("zod");
+const app_workspace_1 = require("../app-workspace");
+Object.defineProperty(exports, "prewarmAppWorkspace", { enumerable: true, get: function () { return app_workspace_1.prewarmAppWorkspace; } });
+const host_1 = require("../host");
+const barrels_1 = require("../run-codegen/barrels");
+const endpoints_1 = require("../run-codegen/endpoints");
+const DEFAULT_API_ENDPOINT = 'http://api.localhost:3000/graphql';
+const RunCodegenZod = zod_1.z.object({});
+function fail(message) {
+    return { content: [{ type: 'text', text: message }], details: { success: false, message } };
+}
+const FETCH_RESET_RE = /Failed to fetch schema|Connection reset|ECONNRESET|socket hang up/i;
+// Read the binding provision_database wrote to the project .env. The
+// API_ENDPOINT pin identifies which backend owns the binding — it wins over
+// the app's current backend config, matching context.ts data-plane precedence.
+async function readProjectEnv(cwd) {
+    try {
+        const env = await (0, promises_1.readFile)(node_path_1.default.join(cwd, '.env'), 'utf8');
+        const read = (key) => env.match(new RegExp(`^${key}=(.+)$`, 'm'))?.[1]?.trim();
+        return { databaseName: read('DATABASE_NAME'), apiEndpoint: read('API_ENDPOINT') };
+    }
+    catch {
+        return {};
+    }
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+// The codegen CLI introspects three live vhosts (admin/auth/app). Under load the
+// Constructive backend intermittently resets a connection mid-introspection
+// ("Failed to fetch schema: Connection reset"), which is transient — a retry
+// almost always clears it. Re-run the whole generate (it rebuilds all targets)
+// up to `attempts` times, only on a fetch/reset failure; any other failure is
+// real and returned immediately (CODEGEN-RETRY-001).
+async function runCodegenWithRetry(appDir, env, attempts = 4) {
+    const sdk = node_path_1.default.join(appDir, 'src', 'graphql', 'sdk');
+    let last = { ok: false, out: 'codegen never ran' };
+    for (let i = 1; i <= attempts; i++) {
+        for (const sub of ['admin', 'auth', 'app']) {
+            await (0, promises_1.rm)(node_path_1.default.join(sdk, sub), { recursive: true, force: true });
+        }
+        last = await (0, app_workspace_1.run)('npx', ['@constructive-io/graphql-codegen', 'generate', '--config', './graphql-codegen.config.ts'], appDir, env);
+        if (last.ok)
+            return last;
+        if (!FETCH_RESET_RE.test(last.out))
+            return last;
+        if (i < attempts)
+            await sleep(2000 * i);
+    }
+    return last;
+}
+exports.runCodegenTool = {
+    name: 'run_codegen',
+    label: 'Run codegen',
+    description: "Generate the typed GraphQL SDK for the project's Next.js app (packages/app). Runs the exact deterministic sequence — scaffold packages/app from the constructive-app template if it doesn't exist yet, hoist the graphql override to the root workspace so a single grafast resolves, pin codegen to latest, do one clean install, run codegen (retrying transient backend connection resets), and normalize SDK barrels for Turbopack. Run AFTER provisioning the database and creating schema; it scaffolds packages/app itself, so no separate `pgpm init` step is needed. The scaffold + install are usually prewarmed during provision_database, so this is fast.",
+    promptSnippet: 'run_codegen: scaffold packages/app (if missing) + regenerate the typed SDK (workspace-config + clean install + codegen-with-retry + barrel-normalize). Run after schema changes. Gated.',
+    parameters: RunCodegenZod,
+    async execute(_params, ctx) {
+        const cwd = ctx.cwd;
+        const appDir = node_path_1.default.join(cwd, 'packages', 'app');
+        // Materialize packages/app deterministically if it isn't there yet — this
+        // replaces the flaky `pgpm init` scaffold step (PGPM-001). When
+        // provision_database prewarmed it, this no-ops.
+        const scaffold = await (0, app_workspace_1.ensureAppScaffold)(cwd);
+        if (!scaffold.ok) {
+            return fail(scaffold.out);
+        }
+        const { databaseName: dbName, apiEndpoint: envApiEndpoint } = await readProjectEnv(cwd);
+        if (!dbName) {
+            return fail('DATABASE_NAME missing from .env — provision the database first, then re-run.');
+        }
+        const backend = (0, host_1.getHost)().backendConfig();
+        const apiEndpoint = envApiEndpoint || backend?.apiEndpoint || DEFAULT_API_ENDPOINT;
+        const planes = (0, endpoints_1.derivePlaneEndpoints)(apiEndpoint, dbName);
+        // The dev server reads .env.local (NEXT_PUBLIC_DB_NAME + per-DB endpoint
+        // overrides so it doesn't fall back to localhost vhosts on a remote
+        // backend); the codegen config reads process.env (passed directly below).
+        try {
+            await (0, promises_1.writeFile)(node_path_1.default.join(appDir, '.env.local'), (0, endpoints_1.envLocalContent)(dbName, planes));
+        }
+        catch (err) {
+            return fail(`Failed to write packages/app/.env.local: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        // Hoist the graphql override to the root workspace (PNPM-GRAPHQL-OVERRIDE-001)
+        // and pin codegen to latest (TS-001) before the single clean install. When
+        // prewarmed by provision_database these are idempotent and the install is a
+        // fast no-op; otherwise this is the first install (PNPM-BUILDS-001).
+        await (0, app_workspace_1.ensureWorkspaceConfig)(cwd);
+        await (0, app_workspace_1.pinCodegenLatest)(appDir);
+        const install = await (0, app_workspace_1.run)('pnpm', ['install', '--no-frozen-lockfile'], cwd);
+        if (!install.ok && !app_workspace_1.IGNORED_BUILDS_RE.test(install.out)) {
+            return fail(`pnpm install failed:\n${install.out}`);
+        }
+        const codegen = await runCodegenWithRetry(appDir, {
+            NEXT_PUBLIC_DB_NAME: dbName,
+            ...(planes ? (0, endpoints_1.codegenEndpointEnv)(planes) : {}),
+        });
+        if (!codegen.ok) {
+            // A reset that survives every internal retry is a backend OUTAGE, not a code
+            // or install problem — re-running run_codegen cannot fix it. Say so explicitly
+            // so the agent marks sdk-codegen `blocked` instead of looping the tool to the
+            // time cap (CODEGEN-OUTAGE-001 / THRASH-001).
+            if (FETCH_RESET_RE.test(codegen.out)) {
+                return fail('codegen failed: BACKEND OUTAGE — the Constructive backend reset the connection ' +
+                    'during schema introspection, and it stayed down across every internal retry. ' +
+                    'This is an EXTERNAL outage, not a code or install problem; re-running run_codegen ' +
+                    'will NOT fix it. Call run_preflight once — if the backend is down, mark ' +
+                    'sdk-codegen `blocked` (SERVER-001, BLOCKED-PROCEED-001) and hand back to ' +
+                    'build-orchestrator. Do NOT loop on run_codegen (THRASH-001).\n\n' +
+                    codegen.out);
+            }
+            return fail(`codegen failed:\n${codegen.out}`);
+        }
+        // Normalize directory barrels so Turbopack can resolve them (TURBOPACK-BARREL-001).
+        const sdkRoot = node_path_1.default.join(appDir, 'src', 'graphql', 'sdk');
+        const barrelsRewritten = (0, barrels_1.normalizeSdkBarrels)(sdkRoot);
+        // Report which app submodules actually generated — a bare scaffold with only
+        // index.ts means codegen had no schema to generate against.
+        const appSdk = node_path_1.default.join(sdkRoot, 'app');
+        const generatedSubmodules = ['hooks', 'orm', 'types'].filter((sub) => (0, node_fs_1.existsSync)(node_path_1.default.join(appSdk, sub)));
+        const message = generatedSubmodules.length > 0
+            ? `Codegen complete. Generated app submodules: ${generatedSubmodules.join(', ')}. Normalized ${barrelsRewritten} barrel file(s).`
+            : `Codegen ran, but no app submodules (hooks/orm/types) were generated — the database may have no entity tables yet. Normalized ${barrelsRewritten} barrel file(s).`;
+        return {
+            content: [{ type: 'text', text: message }],
+            details: {
+                success: generatedSubmodules.length > 0,
+                message,
+                barrelsRewritten,
+                generatedSubmodules,
+            },
+        };
+    },
+};

package/tools/templates.d.ts

@@ -0,0 +1,71 @@
+import { type ConfirmPreviewTable, type HarnessTool } from '@agentic-kit/harness';
+import { z } from 'zod';
+import type { ProjectContext } from '../context';
+export type TemplateDetails = {
+    success: boolean;
+    message: string;
+};
+export type CreateTemplateDetails = TemplateDetails & {
+    displayName?: string;
+    blueprintName?: string;
+    tables?: ConfirmPreviewTable[];
+};
+type TemplateField = {
+    name: string;
+    type: string;
+    isRequired: boolean;
+    defaultValue: string | null;
+};
+type TemplateTable = {
+    name: string;
+    fields: TemplateField[];
+    policies: string[];
+    relationCount: number;
+};
+type TemplateInfo = {
+    displayName: string;
+    description: string | null;
+    categories: string[];
+    tables: TemplateTable[];
+};
+export type ListTemplatesDetails = {
+    templates: TemplateInfo[];
+};
+export type CreateTemplatePreview = {
+    blueprintName: string;
+    tables: ConfirmPreviewTable[];
+};
+export declare function createTemplatePreviewTables(context: ProjectContext, blueprintName: string | undefined): Promise<CreateTemplatePreview>;
+declare const ListTemplatesZod: z.ZodObject<{}, z.core.$strip>;
+export declare const listTemplatesTool: HarnessTool<typeof ListTemplatesZod, ListTemplatesDetails>;
+declare const CreateTemplateZod: z.ZodObject<{
+    displayName: z.ZodString;
+    blueprintName: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    categories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const createTemplateTool: HarnessTool<typeof CreateTemplateZod, CreateTemplateDetails>;
+declare const ApplyTemplateZod: z.ZodObject<{
+    templateName: z.ZodString;
+    nameOverride: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const applyTemplateTool: HarnessTool<typeof ApplyTemplateZod, TemplateDetails>;
+declare const UpdateTemplateZod: z.ZodObject<{
+    templateName: z.ZodString;
+    patch: z.ZodObject<{
+        displayName: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        categories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        visibility: z.ZodOptional<z.ZodEnum<{
+            public: "public";
+            private: "private";
+        }>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const updateTemplateTool: HarnessTool<typeof UpdateTemplateZod, TemplateDetails>;
+declare const DeleteTemplateZod: z.ZodObject<{
+    templateName: z.ZodString;
+}, z.core.$strip>;
+export declare const deleteTemplateTool: HarnessTool<typeof DeleteTemplateZod, TemplateDetails>;
+export {};

package/tools/templates.js

@@ -0,0 +1,335 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteTemplateTool = exports.updateTemplateTool = exports.applyTemplateTool = exports.createTemplateTool = exports.listTemplatesTool = void 0;
+exports.createTemplatePreviewTables = createTemplatePreviewTables;
+const harness_1 = require("@agentic-kit/harness");
+const zod_1 = require("zod");
+const context_1 = require("../context");
+// A stored blueprint field's `type` is an expanded object (`{ name: 'text' }`),
+// not the bare string the agent passes to provision_blueprint. Flatten it to the
+// type name so the renderer gets a string, never an object (which React can't
+// render as a child).
+function fieldTypeName(raw) {
+    if (typeof raw === 'string')
+        return raw;
+    if (raw && typeof raw === 'object' && typeof raw.name === 'string') {
+        return raw.name;
+    }
+    return '';
+}
+// A template's definition is a stored blueprint (see BlueprintDefinitionSchema):
+// { tables: [{ table_name, fields, policies }], relations: [{ source_table, … }] }.
+// Parse it into the same table shape provision_blueprint surfaces so the renderer
+// can reuse TableCard. Defensive throughout — it's untyped JSON from the catalog.
+function parseTemplateTables(definition) {
+    if (!definition || typeof definition !== 'object')
+        return [];
+    const def = definition;
+    const tables = Array.isArray(def.tables) ? def.tables : [];
+    const relations = Array.isArray(def.relations) ? def.relations : [];
+    return tables.map((raw) => {
+        const table = raw;
+        const fields = Array.isArray(table.fields) ? table.fields : [];
+        const policies = Array.isArray(table.policies) ? table.policies : [];
+        return {
+            name: table.table_name ?? '',
+            fields: fields.map((rawField) => {
+                const field = rawField;
+                return {
+                    name: field.name ?? '',
+                    type: fieldTypeName(field.type),
+                    isRequired: field.is_required ?? false,
+                    defaultValue: typeof field.default === 'string' ? field.default : null,
+                };
+            }),
+            policies: (0, harness_1.filterInternalPolicies)(policies.map((policy) => policy.$type ?? '').filter(Boolean)),
+            relationCount: relations.filter((relation) => relation.source_table === table.table_name).length,
+        };
+    });
+}
+function formatTemplatesText(templates) {
+    if (templates.length === 0)
+        return 'No blueprint templates available.';
+    const lines = [`Available blueprint templates (${templates.length}):`];
+    for (const template of templates) {
+        const cats = template.categories.length ? ` [${template.categories.join(', ')}]` : '';
+        lines.push(`  ${template.displayName} — ${template.tables.length} tables${cats}`);
+        for (const table of template.tables) {
+            lines.push(`    - ${table.name} (${table.fields.length} field${table.fields.length === 1 ? '' : 's'})`);
+        }
+    }
+    return lines.join('\n');
+}
+// The latest project blueprint (or a named one) — the definition source for
+// create_template, and for the confirm preview of the tables it will template.
+// A blueprintName is a best-effort hint: if it matches nothing (the agent often
+// guesses casing/wording), fall back to the most recent blueprint so the confirm
+// still previews real tables and execute templates the same one it previewed.
+async function fetchLatestBlueprint(context, blueprintName) {
+    const found = await context.modules.blueprint
+        .findMany({
+        select: { displayName: true, definition: true },
+        where: {
+            databaseId: { equalTo: context.databaseId },
+            ...(blueprintName ? { displayName: { equalTo: blueprintName } } : {}),
+        },
+        orderBy: ['CREATED_AT_DESC'],
+        first: 1,
+    })
+        .unwrap();
+    return found.blueprints?.nodes?.[0];
+}
+async function findProjectBlueprint(context, blueprintName) {
+    let node = await fetchLatestBlueprint(context, blueprintName);
+    if (!node && blueprintName)
+        node = await fetchLatestBlueprint(context, undefined);
+    return node?.definition ? { displayName: node.displayName ?? '', definition: node.definition } : null;
+}
+// The create_template confirm preview — the source blueprint's name and its
+// tables, parsed into the shape the renderer's TableCard reuses. Best-effort: any
+// failure yields no tables rather than blocking the confirm.
+async function createTemplatePreviewTables(context, blueprintName) {
+    try {
+        const blueprint = await findProjectBlueprint(context, blueprintName);
+        if (!blueprint)
+            return { blueprintName: '', tables: [] };
+        return {
+            blueprintName: blueprint.displayName,
+            tables: parseTemplateTables(blueprint.definition),
+        };
+    }
+    catch (err) {
+        console.warn('[db-tools] create_template preview lookup failed:', err);
+        return { blueprintName: '', tables: [] };
+    }
+}
+async function resolveTemplateId(client, displayName) {
+    const result = await client.blueprintTemplate
+        .findMany({
+        select: { id: true, displayName: true },
+        where: { displayName: { equalTo: displayName } },
+        first: 1,
+    })
+        .unwrap();
+    const template = result.blueprintTemplates?.nodes?.[0];
+    if (!template?.id)
+        throw new Error(`Template "${displayName}" not found`);
+    return template.id;
+}
+function done(success, message) {
+    return { content: [{ type: 'text', text: message }], details: { success, message } };
+}
+// ── list_templates ────────────────────────────────────────────────────────
+const ListTemplatesZod = zod_1.z.object({});
+exports.listTemplatesTool = {
+    name: 'list_templates',
+    label: 'List templates',
+    description: 'List the blueprint templates available to provision into the project database (display name, description, categories, table count). Read-only — these are a global catalog, not the project schema.',
+    promptSnippet: 'list_templates: list the available blueprint templates to apply. Read-only — call before apply_template.',
+    parameters: ListTemplatesZod,
+    async execute(_params, ctx) {
+        const resolved = await (0, context_1.resolveProjectContext)(ctx.cwd);
+        if (!resolved.context) {
+            return { content: [{ type: 'text', text: resolved.reason }], details: { templates: [] } };
+        }
+        const result = await resolved.context.modules.blueprintTemplate
+            .findMany({
+            select: {
+                displayName: true,
+                description: true,
+                categories: true,
+                definition: true,
+            },
+            orderBy: ['NAME_ASC'],
+        })
+            .execute();
+        if (!result.ok) {
+            const message = result.errors.map((e) => e.message).join('; ');
+            return {
+                content: [{ type: 'text', text: `Failed to read templates: ${message}` }],
+                details: { templates: [] },
+            };
+        }
+        const templates = (result.data.blueprintTemplates?.nodes ?? []).map((template) => ({
+            displayName: template.displayName ?? '',
+            description: template.description ?? null,
+            categories: Array.isArray(template.categories) ? template.categories : [],
+            tables: parseTemplateTables(template.definition),
+        }));
+        return {
+            content: [{ type: 'text', text: formatTemplatesText(templates) }],
+            details: { templates },
+        };
+    },
+};
+// ── create_template ───────────────────────────────────────────────────────
+const CreateTemplateZod = zod_1.z.object({
+    displayName: zod_1.z.string().describe('Display name for the new blueprint template'),
+    blueprintName: zod_1.z
+        .string()
+        .describe('Display name of an existing project blueprint to save as the template. Defaults to the most recently provisioned blueprint.')
+        .optional(),
+    description: zod_1.z.string().describe('Description shown in the template catalog').optional(),
+    categories: zod_1.z
+        .array(zod_1.z.string())
+        .describe('Categories for catalog grouping and discovery')
+        .optional(),
+});
+exports.createTemplateTool = {
+    name: 'create_template',
+    label: 'Create template',
+    description: 'Save an existing project blueprint into the global template catalog as a reusable blueprint template. Defaults to the most recently provisioned blueprint; pass blueprintName to pick a specific one by display name. Gated.',
+    promptSnippet: 'create_template: save a project blueprint to the reusable template catalog. Gated.',
+    parameters: CreateTemplateZod,
+    async execute(params, ctx) {
+        const resolved = await (0, context_1.resolveProjectContext)(ctx.cwd);
+        if (!resolved.context)
+            return done(false, resolved.reason);
+        const { modules, ownerId } = resolved.context;
+        if (!ownerId)
+            return done(false, 'Not authenticated (missing OWNER_ID in .env).');
+        try {
+            const blueprint = await findProjectBlueprint(resolved.context, params.blueprintName);
+            if (!blueprint) {
+                const which = params.blueprintName ? `"${params.blueprintName}"` : 'any blueprint';
+                return done(false, `No project blueprint found (${which}). Provision a blueprint first.`);
+            }
+            const base = params.displayName.toLowerCase().replace(/\s+/g, '_');
+            await modules.blueprintTemplate
+                .create({
+                data: {
+                    ownerId,
+                    name: `${base}_${Date.now()}`,
+                    displayName: params.displayName,
+                    description: params.description,
+                    categories: params.categories,
+                    definition: blueprint.definition,
+                },
+                select: { id: true, displayName: true },
+            })
+                .unwrap();
+            const message = `Created template "${params.displayName}"`;
+            return {
+                content: [{ type: 'text', text: message }],
+                details: {
+                    success: true,
+                    message,
+                    displayName: params.displayName,
+                    blueprintName: blueprint.displayName,
+                    tables: parseTemplateTables(blueprint.definition),
+                },
+            };
+        }
+        catch (err) {
+            return done(false, err instanceof Error ? err.message : 'Failed to create template');
+        }
+    },
+};
+// ── apply_template ────────────────────────────────────────────────────────
+const ApplyTemplateZod = zod_1.z.object({
+    templateName: zod_1.z.string().describe('The display name of the blueprint template to apply'),
+    nameOverride: zod_1.z
+        .string()
+        .describe('Optional name override for the created blueprint (snake_case). Defaults to template name.')
+        .optional(),
+});
+exports.applyTemplateTool = {
+    name: 'apply_template',
+    label: 'Apply template',
+    description: 'Apply an existing blueprint template to the project database, creating its tables. Use the template display name (from list_templates).',
+    promptSnippet: 'apply_template: provision a saved blueprint template by display name. Gated.',
+    parameters: ApplyTemplateZod,
+    async execute(params, ctx) {
+        const resolved = await (0, context_1.resolveProjectContext)(ctx.cwd);
+        if (!resolved.context)
+            return done(false, resolved.reason);
+        const { modules, databaseId, schemaId, ownerId } = resolved.context;
+        if (!ownerId)
+            return done(false, 'Not authenticated (missing OWNER_ID in .env).');
+        try {
+            const templateId = await resolveTemplateId(modules, params.templateName);
+            const base = params.nameOverride ?? params.templateName.toLowerCase().replace(/\s+/g, '_');
+            const nameOverride = `${base}_${Date.now()}`;
+            const copyResult = await modules.mutation
+                .copyTemplateToBlueprint({ input: { templateId, databaseId, ownerId, nameOverride } }, { select: { result: true } })
+                .unwrap();
+            const blueprintId = copyResult.copyTemplateToBlueprint?.result;
+            if (!blueprintId)
+                throw new Error('Failed to copy template');
+            const constructResult = await modules.mutation
+                .constructBlueprint({ input: { blueprintId, schemaId } }, { select: { result: true } })
+                .unwrap();
+            const refMap = constructResult.constructBlueprint?.result;
+            if (!refMap)
+                return done(false, `Construction failed for template "${params.templateName}"`);
+            const createdCount = Object.keys(refMap).length;
+            return done(true, `Applied template "${params.templateName}" — created ${createdCount} table${createdCount === 1 ? '' : 's'}`);
+        }
+        catch (err) {
+            return done(false, err instanceof Error ? err.message : 'Failed to apply template');
+        }
+    },
+};
+// ── update_template ───────────────────────────────────────────────────────
+const UpdateTemplateZod = zod_1.z.object({
+    templateName: zod_1.z.string().describe('The display name of the blueprint template to update'),
+    patch: zod_1.z.object({
+        displayName: zod_1.z.string().describe('New display name').optional(),
+        description: zod_1.z.string().describe('New description').optional(),
+        categories: zod_1.z.array(zod_1.z.string()).describe('New categories').optional(),
+        tags: zod_1.z.array(zod_1.z.string()).describe('New tags').optional(),
+        visibility: zod_1.z.enum(['private', 'public']).describe('New visibility').optional(),
+    }),
+});
+exports.updateTemplateTool = {
+    name: 'update_template',
+    label: 'Update template',
+    description: 'Update a blueprint template’s metadata (display name, description, categories, tags, visibility).',
+    promptSnippet: 'update_template: edit a saved template’s metadata by display name. Gated.',
+    parameters: UpdateTemplateZod,
+    async execute(params, ctx) {
+        const resolved = await (0, context_1.resolveProjectContext)(ctx.cwd);
+        if (!resolved.context)
+            return done(false, resolved.reason);
+        try {
+            const templateId = await resolveTemplateId(resolved.context.modules, params.templateName);
+            await resolved.context.modules.blueprintTemplate
+                .update({
+                where: { id: templateId },
+                data: params.patch,
+                select: { id: true, displayName: true },
+            })
+                .unwrap();
+            return done(true, `Updated template "${params.templateName}"`);
+        }
+        catch (err) {
+            return done(false, err instanceof Error ? err.message : 'Failed to update template');
+        }
+    },
+};
+// ── delete_template ───────────────────────────────────────────────────────
+const DeleteTemplateZod = zod_1.z.object({
+    templateName: zod_1.z.string().describe('The display name of the blueprint template to delete'),
+});
+exports.deleteTemplateTool = {
+    name: 'delete_template',
+    label: 'Delete template',
+    description: 'Permanently delete a blueprint template by its display name.',
+    promptSnippet: 'delete_template: remove a saved template by display name. Destructive — gated.',
+    parameters: DeleteTemplateZod,
+    async execute(params, ctx) {
+        const resolved = await (0, context_1.resolveProjectContext)(ctx.cwd);
+        if (!resolved.context)
+            return done(false, resolved.reason);
+        try {
+            const templateId = await resolveTemplateId(resolved.context.modules, params.templateName);
+            await resolved.context.modules.blueprintTemplate
+                .delete({ where: { id: templateId }, select: { id: true } })
+                .unwrap();
+            return done(true, `Deleted template "${params.templateName}"`);
+        }
+        catch (err) {
+            return done(false, err instanceof Error ? err.message : 'Failed to delete template');
+        }
+    },
+};