@agentic-kit/pi 0.2.0

package/tools/add-relation-schema.d.ts

@@ -0,0 +1,30 @@
+import type { BlueprintDefinition } from '@agentic-kit/harness';
+import { z } from 'zod';
+export declare const DeleteAction: z.ZodEnum<{
+    c: "c";
+    r: "r";
+    n: "n";
+    a: "a";
+    d: "d";
+}>;
+export declare const AddRelationZod: z.ZodObject<{
+    relation_type: z.ZodOptional<z.ZodEnum<{
+        belongs_to: "belongs_to";
+        many_to_many: "many_to_many";
+    }>>;
+    source_table: z.ZodString;
+    target_table: z.ZodString;
+    field_name: z.ZodOptional<z.ZodString>;
+    junction_table_name: z.ZodOptional<z.ZodString>;
+    delete_action: z.ZodOptional<z.ZodEnum<{
+        c: "c";
+        r: "r";
+        n: "n";
+        a: "a";
+        d: "d";
+    }>>;
+    is_required: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const AddRelationSchema: import("typebox/type").TSchema;
+export type AddRelationParams = z.infer<typeof AddRelationZod>;
+export declare function buildRelation(params: AddRelationParams): BlueprintDefinition['relations'];

package/tools/add-relation-schema.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddRelationSchema = exports.AddRelationZod = exports.DeleteAction = void 0;
+exports.buildRelation = buildRelation;
+const zod_1 = require("zod");
+const tool_schema_1 = require("../tool-schema");
+// delete_action is intentionally always sent: the backend REJECTS a
+// RelationBelongsTo whose delete_action is absent ("PROVISION_RELATION:
+// delete_action is required"). We default it to 'a' (NO ACTION) so the model
+// never has to supply it.
+exports.DeleteAction = zod_1.z
+    .enum(['c', 'r', 'n', 'a', 'd'])
+    .describe('FK delete action: c=CASCADE, r=RESTRICT, n=SET NULL, a=NO ACTION (default), d=SET DEFAULT');
+exports.AddRelationZod = zod_1.z.object({
+    relation_type: zod_1.z
+        .enum(['belongs_to', 'many_to_many'])
+        .describe('belongs_to adds an FK column on the source table; many_to_many adds a junction table. Defaults to belongs_to.')
+        .optional(),
+    source_table: zod_1.z.string().describe('Existing source table name (snake_case).'),
+    target_table: zod_1.z.string().describe('Existing target table name (snake_case).'),
+    field_name: zod_1.z
+        .string()
+        .describe('belongs_to only: FK column name to add on the source table, e.g. "author_id".')
+        .optional(),
+    junction_table_name: zod_1.z
+        .string()
+        .describe('many_to_many only: name of the junction table to create, e.g. "post_tags".')
+        .optional(),
+    delete_action: exports.DeleteAction.optional(),
+    is_required: zod_1.z
+        .boolean()
+        .describe('belongs_to only: make the FK NOT NULL. Defaults to false — a NOT NULL FK fails if the source table already has rows.')
+        .optional(),
+});
+exports.AddRelationSchema = (0, tool_schema_1.toolSchema)(exports.AddRelationZod);
+// Build a relation-only blueprint definition (no tables): the spike proved
+// constructBlueprint applies relations to PRE-EXISTING tables without recreating
+// them, as long as delete_action is supplied.
+function buildRelation(params) {
+    const deleteAction = params.delete_action ?? 'a';
+    if ((params.relation_type ?? 'belongs_to') === 'many_to_many') {
+        return [
+            {
+                $type: 'RelationManyToMany',
+                source_table: params.source_table,
+                target_table: params.target_table,
+                junction_table_name: params.junction_table_name,
+                delete_action: deleteAction,
+            },
+        ];
+    }
+    return [
+        {
+            $type: 'RelationBelongsTo',
+            source_table: params.source_table,
+            target_table: params.target_table,
+            field_name: params.field_name,
+            delete_action: deleteAction,
+            is_required: params.is_required ?? false,
+        },
+    ];
+}

package/tools/add-relation.d.ts

@@ -0,0 +1,10 @@
+import type { ToolDefinition } from '@earendil-works/pi-coding-agent';
+import { AddRelationSchema } from './add-relation-schema';
+export type AddRelationDetails = {
+    success: boolean;
+    message: string;
+    sourceTable?: string;
+    targetTable?: string;
+    fieldName?: string;
+};
+export declare const addRelationTool: ToolDefinition<typeof AddRelationSchema, AddRelationDetails>;

package/tools/add-relation.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addRelationTool = void 0;
+const harness_1 = require("@agentic-kit/harness");
+const context_1 = require("../context");
+const schema_resolve_1 = require("../schema-resolve");
+const add_relation_schema_1 = require("./add-relation-schema");
+function fail(message) {
+    return { content: [{ type: 'text', text: message }], details: { success: false, message } };
+}
+exports.addRelationTool = {
+    name: 'add_relation',
+    label: 'Add relation',
+    description: 'Add a relation between two EXISTING tables without recreating them: belongs_to adds a foreign-key column on the source table; many_to_many creates a junction table. Use this for relations discovered after the tables were provisioned. For brand-new related tables, prefer a single provision_blueprint call.',
+    promptSnippet: 'add_relation: link two existing tables (belongs_to FK column, or many_to_many junction). Gated.',
+    parameters: add_relation_schema_1.AddRelationSchema,
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+        const type = params.relation_type ?? 'belongs_to';
+        if (type === 'belongs_to' && !params.field_name) {
+            return fail('field_name is required for a belongs_to relation (the FK column name on the source table).');
+        }
+        if (type === 'many_to_many' && !params.junction_table_name) {
+            return fail('junction_table_name is required for a many_to_many relation.');
+        }
+        const resolved = await (0, context_1.resolveProjectContext)(ctx.cwd);
+        if (!resolved.context)
+            return fail(resolved.reason);
+        const { modules, databaseId, schemaId, ownerId } = resolved.context;
+        if (!ownerId)
+            return fail('Not authenticated (missing OWNER_ID in .env).');
+        // Validate both tables exist before constructing — a clearer error than the
+        // backend's, and avoids a no-op blueprint.
+        let schema;
+        try {
+            schema = await (0, schema_resolve_1.resolveSchema)(resolved.context);
+            (0, schema_resolve_1.resolveTable)(schema, params.source_table);
+            (0, schema_resolve_1.resolveTable)(schema, params.target_table);
+        }
+        catch (err) {
+            return fail(err instanceof Error ? err.message : 'Failed to resolve schema.');
+        }
+        const definition = (0, harness_1.expandBlueprintDefaults)({ tables: [], relations: (0, add_relation_schema_1.buildRelation)(params) });
+        const uniqueName = `add_relation_${Date.now()}`;
+        try {
+            const created = await modules.blueprint
+                .create({
+                data: {
+                    ownerId,
+                    databaseId,
+                    name: uniqueName,
+                    displayName: `${params.source_table} → ${params.target_table}`,
+                    description: `Add ${type} relation`,
+                    definition,
+                },
+                select: { id: true },
+            })
+                .unwrap();
+            const blueprintId = created.createBlueprint?.blueprint?.id;
+            if (!blueprintId)
+                throw new Error('Failed to create relation blueprint');
+            const constructResult = await modules.mutation
+                .constructBlueprint({ input: { blueprintId, schemaId } }, { select: { result: true } })
+                .unwrap();
+            if (!constructResult.constructBlueprint?.result) {
+                const constructions = await modules.blueprintConstruction
+                    .findMany({
+                    where: { blueprintId: { equalTo: blueprintId } },
+                    orderBy: ['ID_DESC'],
+                    first: 1,
+                    select: { status: true, errorDetails: true },
+                })
+                    .unwrap();
+                const error = constructions?.blueprintConstructions?.nodes?.[0]?.errorDetails ?? 'Unknown error';
+                return fail(`Failed to add relation: ${typeof error === 'string' ? error : JSON.stringify(error)}`);
+            }
+        }
+        catch (err) {
+            return fail(`Failed to add relation: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        const message = type === 'many_to_many'
+            ? `Created junction table "${params.junction_table_name}" linking ${params.source_table} ↔ ${params.target_table}.`
+            : `Added FK "${params.field_name}" on ${params.source_table} → ${params.target_table}.`;
+        return {
+            content: [{ type: 'text', text: message }],
+            details: {
+                success: true,
+                message,
+                sourceTable: params.source_table,
+                targetTable: params.target_table,
+                fieldName: params.field_name,
+            },
+        };
+    },
+};

package/tools/describe-schema.d.ts

@@ -0,0 +1,18 @@
+import type { ToolDefinition } from '@earendil-works/pi-coding-agent';
+declare const ParamSchema: import("typebox/type").TSchema;
+type SchemaField = {
+    name: string;
+    type: string;
+    isRequired: boolean;
+    defaultValue: string | null;
+};
+type SchemaTable = {
+    name: string;
+    fields: SchemaField[];
+    policies: string[];
+};
+export type DescribeSchemaDetails = {
+    tables: SchemaTable[];
+};
+export declare const describeSchemaTool: ToolDefinition<typeof ParamSchema, DescribeSchemaDetails>;
+export {};

package/tools/describe-schema.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeSchemaTool = void 0;
+const harness_1 = require("@agentic-kit/harness");
+const zod_1 = require("zod");
+const context_1 = require("../context");
+const tool_schema_1 = require("../tool-schema");
+const ParamZod = zod_1.z.object({});
+const ParamSchema = (0, tool_schema_1.toolSchema)(ParamZod);
+function toDefaultValueString(value) {
+    if (value == null)
+        return null;
+    if (typeof value === 'string')
+        return value;
+    return JSON.stringify(value);
+}
+function formatText(details) {
+    const lines = [];
+    if (details.tables.length === 0) {
+        lines.push('No application tables yet.');
+    }
+    else {
+        lines.push(`Tables (${details.tables.length}):`);
+        for (const table of details.tables) {
+            lines.push(`  ${table.name}`);
+            for (const field of table.fields) {
+                const req = field.isRequired ? ' required' : '';
+                const def = field.defaultValue != null ? ` default=${field.defaultValue}` : '';
+                lines.push(`    - ${field.name}: ${field.type}${req}${def}`);
+            }
+            if (table.policies.length > 0) {
+                lines.push(`    policies: ${table.policies.join(', ')}`);
+            }
+        }
+    }
+    return lines.join('\n');
+}
+exports.describeSchemaTool = {
+    name: 'describe_schema',
+    label: 'Describe schema',
+    description: 'Inspect the current Constructive database schema for this project: application tables with their fields (name, type, required, default). Read-only.',
+    promptSnippet: 'describe_schema: list the project database tables and their fields. Read-only — call before modifying schema.',
+    parameters: ParamSchema,
+    async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
+        const resolved = await (0, context_1.resolveProjectContext)(ctx.cwd);
+        if (!resolved.context) {
+            return {
+                content: [{ type: 'text', text: resolved.reason }],
+                details: { tables: [] },
+            };
+        }
+        const { api, databaseId } = resolved.context;
+        const tablesResult = await api.table
+            .findMany({
+            select: { id: true, name: true, category: true },
+            where: {
+                databaseId: { equalTo: databaseId },
+                or: [{ category: { equalTo: 'APP' } }, { name: { equalTo: 'users' } }],
+            },
+            orderBy: ['NAME_ASC'],
+        })
+            .execute();
+        if (!tablesResult.ok) {
+            const message = tablesResult.errors.map((e) => e.message).join('; ');
+            return {
+                content: [{ type: 'text', text: `Failed to read schema: ${message}` }],
+                details: { tables: [] },
+            };
+        }
+        const tableNodes = tablesResult.data.tables?.nodes ?? [];
+        const tableIds = tableNodes.map((t) => t.id);
+        const fieldsByTable = new Map();
+        const policiesByTable = new Map();
+        if (tableIds.length > 0) {
+            const [fieldsResult, policiesResult] = await Promise.all([
+                api.field
+                    .findMany({
+                    select: {
+                        name: true,
+                        type: true,
+                        isRequired: true,
+                        defaultValue: true,
+                        tableId: true,
+                    },
+                    where: { tableId: { in: tableIds } },
+                })
+                    .execute(),
+                api.policy
+                    .findMany({
+                    select: { tableId: true, policyType: true },
+                    where: { tableId: { in: tableIds } },
+                })
+                    .execute(),
+            ]);
+            if (!fieldsResult.ok) {
+                const message = fieldsResult.errors.map((e) => e.message).join('; ');
+                return {
+                    content: [{ type: 'text', text: `Failed to read fields: ${message}` }],
+                    details: { tables: [] },
+                };
+            }
+            for (const field of fieldsResult.data.fields?.nodes ?? []) {
+                const list = fieldsByTable.get(field.tableId) ?? [];
+                list.push({
+                    name: field.name,
+                    type: (0, harness_1.fieldTypeToTypeName)(field.type),
+                    isRequired: Boolean(field.isRequired),
+                    defaultValue: toDefaultValueString(field.defaultValue),
+                });
+                fieldsByTable.set(field.tableId, list);
+            }
+            // One policy spans CRUD as several rows; collapse to distinct types per table.
+            if (policiesResult.ok) {
+                for (const policy of policiesResult.data.policies?.nodes ?? []) {
+                    if ((0, harness_1.isInternalPolicy)(policy.policyType))
+                        continue;
+                    const list = policiesByTable.get(policy.tableId) ?? [];
+                    if (!list.includes(policy.policyType))
+                        list.push(policy.policyType);
+                    policiesByTable.set(policy.tableId, list);
+                }
+            }
+        }
+        const tables = tableNodes.map((table) => ({
+            name: table.name,
+            fields: fieldsByTable.get(table.id) ?? [],
+            policies: policiesByTable.get(table.id) ?? [],
+        }));
+        const details = { tables };
+        return {
+            content: [{ type: 'text', text: formatText(details) }],
+            details,
+        };
+    },
+};

package/tools/mutations.d.ts

@@ -0,0 +1,14 @@
+import type { ToolDefinition } from '@earendil-works/pi-coding-agent';
+export type MutationDetails = {
+    success: boolean;
+    message: string;
+};
+declare const DeleteTableSchema: import("typebox/type").TSchema;
+export declare const deleteTableTool: ToolDefinition<typeof DeleteTableSchema, MutationDetails>;
+declare const CreateFieldSchema: import("typebox/type").TSchema;
+export declare const createFieldTool: ToolDefinition<typeof CreateFieldSchema, MutationDetails>;
+declare const UpdateFieldSchema: import("typebox/type").TSchema;
+export declare const updateFieldTool: ToolDefinition<typeof UpdateFieldSchema, MutationDetails>;
+declare const DeleteFieldSchema: import("typebox/type").TSchema;
+export declare const deleteFieldTool: ToolDefinition<typeof DeleteFieldSchema, MutationDetails>;
+export {};

package/tools/mutations.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteFieldTool = exports.updateFieldTool = exports.createFieldTool = exports.deleteTableTool = void 0;
+const harness_1 = require("@agentic-kit/harness");
+const zod_1 = require("zod");
+const context_1 = require("../context");
+const schema_resolve_1 = require("../schema-resolve");
+const tool_schema_1 = require("../tool-schema");
+function ok(message) {
+    return {
+        content: [{ type: 'text', text: message }],
+        details: { success: true, message },
+    };
+}
+function fail(message) {
+    return {
+        content: [{ type: 'text', text: message }],
+        details: { success: false, message },
+    };
+}
+// ── delete_table ──────────────────────────────────────────────────────────
+const DeleteTableZod = zod_1.z.object({
+    table_name: zod_1.z.string().describe('Name of the table to delete (snake_case)'),
+});
+const DeleteTableSchema = (0, tool_schema_1.toolSchema)(DeleteTableZod);
+exports.deleteTableTool = {
+    name: 'delete_table',
+    label: 'Delete table',
+    description: 'Permanently delete a table and its data from the project database.',
+    promptSnippet: 'delete_table: drop an existing table by name. Destructive — gated.',
+    parameters: DeleteTableSchema,
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+        const resolved = await (0, context_1.resolveProjectContext)(ctx.cwd);
+        if (!resolved.context)
+            return fail(resolved.reason);
+        try {
+            const schema = await (0, schema_resolve_1.resolveSchema)(resolved.context);
+            const table = (0, schema_resolve_1.resolveTable)(schema, params.table_name);
+            await resolved.context.api.table
+                .delete({ where: { id: table.id }, select: { id: true } })
+                .unwrap();
+            return ok(`Deleted table ${params.table_name}`);
+        }
+        catch (err) {
+            return fail(err instanceof Error ? err.message : 'Failed to delete table');
+        }
+    },
+};
+// ── create_field ──────────────────────────────────────────────────────────
+const CreateFieldZod = zod_1.z.object({
+    table_name: zod_1.z.string().describe('Name of the table to add the field to'),
+    field_name: zod_1.z.string().describe('Field name in snake_case'),
+    type: zod_1.z
+        .string()
+        .describe('PostgreSQL type: text, integer, smallint, numeric, boolean, date, timestamp, timestamptz, time, json, jsonb, inet, email, url, image, upload'),
+    is_required: zod_1.z.boolean().describe('Whether the field is NOT NULL. Defaults to false.').optional(),
+    default_value: zod_1.z
+        .union([zod_1.z.string(), zod_1.z.null()])
+        .describe('SQL default expression, e.g. "now()", "\'draft\'"')
+        .optional(),
+    is_unique: zod_1.z
+        .boolean()
+        .describe('Whether the field has a unique constraint. Defaults to false.')
+        .optional(),
+});
+const CreateFieldSchema = (0, tool_schema_1.toolSchema)(CreateFieldZod);
+exports.createFieldTool = {
+    name: 'create_field',
+    label: 'Create field',
+    description: 'Add a new field (column) to an existing table in the project database.',
+    promptSnippet: 'create_field: add a column to an existing table. Gated.',
+    parameters: CreateFieldSchema,
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+        const resolved = await (0, context_1.resolveProjectContext)(ctx.cwd);
+        if (!resolved.context)
+            return fail(resolved.reason);
+        const { api, databaseId } = resolved.context;
+        try {
+            const schema = await (0, schema_resolve_1.resolveSchema)(resolved.context);
+            const table = (0, schema_resolve_1.resolveTable)(schema, params.table_name);
+            const result = await api.field
+                .create({
+                data: {
+                    name: params.field_name,
+                    type: (0, harness_1.toFieldType)(params.type),
+                    tableId: table.id,
+                    databaseId,
+                    isRequired: params.is_required ?? false,
+                    defaultValue: (0, harness_1.toFieldDefault)(params.default_value),
+                },
+                select: { id: true, name: true, type: true },
+            })
+                .unwrap();
+            const createdId = result.createField?.field?.id;
+            if (params.is_unique && createdId) {
+                try {
+                    await api.uniqueConstraint
+                        .create({
+                        data: {
+                            tableId: table.id,
+                            databaseId,
+                            fieldIds: [createdId],
+                            name: `${table.name}_${params.field_name}_key`,
+                            type: 'u',
+                        },
+                        select: { id: true },
+                    })
+                        .unwrap();
+                }
+                catch (err) {
+                    console.warn('Failed to create unique constraint:', err);
+                }
+            }
+            return ok(`Added field ${params.table_name}.${params.field_name}`);
+        }
+        catch (err) {
+            return fail(err instanceof Error ? err.message : 'Failed to create field');
+        }
+    },
+};
+// ── update_field ──────────────────────────────────────────────────────────
+const UpdateFieldZod = zod_1.z.object({
+    table_name: zod_1.z.string().describe('Name of the table containing the field'),
+    field_name: zod_1.z.string().describe('Current field name'),
+    new_name: zod_1.z.string().describe('New field name in snake_case (if renaming)').optional(),
+    new_type: zod_1.z.string().describe('New PostgreSQL type (if changing type)').optional(),
+    is_required: zod_1.z.boolean().describe('Set NOT NULL constraint').optional(),
+    default_value: zod_1.z
+        .union([zod_1.z.string(), zod_1.z.null()])
+        .describe('New SQL default expression, or null to remove')
+        .optional(),
+    is_unique: zod_1.z.boolean().describe('Set or remove unique constraint').optional(),
+});
+const UpdateFieldSchema = (0, tool_schema_1.toolSchema)(UpdateFieldZod);
+exports.updateFieldTool = {
+    name: 'update_field',
+    label: 'Update field',
+    description: 'Modify an existing field: rename, change type, toggle required/unique, or set default.',
+    promptSnippet: 'update_field: rename/retype/toggle an existing column. Gated.',
+    parameters: UpdateFieldSchema,
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+        const resolved = await (0, context_1.resolveProjectContext)(ctx.cwd);
+        if (!resolved.context)
+            return fail(resolved.reason);
+        const { api, databaseId } = resolved.context;
+        try {
+            const schema = await (0, schema_resolve_1.resolveSchema)(resolved.context);
+            const table = (0, schema_resolve_1.resolveTable)(schema, params.table_name);
+            const field = (0, schema_resolve_1.resolveField)(table, params.field_name);
+            const patch = {};
+            if (params.new_name)
+                patch.name = params.new_name;
+            if (params.new_type)
+                patch.type = (0, harness_1.toFieldType)(params.new_type);
+            if (params.is_required !== undefined)
+                patch.isRequired = params.is_required;
+            if (params.default_value !== undefined) {
+                patch.defaultValue =
+                    params.default_value === null ? null : ((0, harness_1.toFieldDefault)(params.default_value) ?? null);
+            }
+            if (Object.keys(patch).length > 0) {
+                await api.field
+                    .update({
+                    where: { id: field.id },
+                    data: patch,
+                    select: { id: true, name: true, type: true },
+                })
+                    .unwrap();
+            }
+            if (params.is_unique !== undefined) {
+                const existingUniqueId = (0, schema_resolve_1.findUniqueConstraintId)(table, field.id);
+                if (params.is_unique && !existingUniqueId) {
+                    try {
+                        await api.uniqueConstraint
+                            .create({
+                            data: {
+                                tableId: table.id,
+                                databaseId,
+                                fieldIds: [field.id],
+                                name: `${table.name}_${params.new_name ?? field.name}_key`,
+                                type: 'u',
+                            },
+                            select: { id: true },
+                        })
+                            .unwrap();
+                    }
+                    catch (err) {
+                        console.warn('Failed to create unique constraint:', err);
+                    }
+                }
+                else if (!params.is_unique && existingUniqueId) {
+                    try {
+                        await api.uniqueConstraint
+                            .delete({ where: { id: existingUniqueId }, select: { id: true } })
+                            .unwrap();
+                    }
+                    catch (err) {
+                        console.warn('Failed to delete unique constraint:', err);
+                    }
+                }
+            }
+            return ok(`Updated field ${params.table_name}.${params.field_name}`);
+        }
+        catch (err) {
+            return fail(err instanceof Error ? err.message : 'Failed to update field');
+        }
+    },
+};
+// ── delete_field ──────────────────────────────────────────────────────────
+const DeleteFieldZod = zod_1.z.object({
+    table_name: zod_1.z.string().describe('Name of the table containing the field'),
+    field_name: zod_1.z.string().describe('Name of the field to delete'),
+});
+const DeleteFieldSchema = (0, tool_schema_1.toolSchema)(DeleteFieldZod);
+exports.deleteFieldTool = {
+    name: 'delete_field',
+    label: 'Delete field',
+    description: 'Permanently delete a field (column) from an existing table.',
+    promptSnippet: 'delete_field: drop a column from a table by name. Destructive — gated.',
+    parameters: DeleteFieldSchema,
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+        const resolved = await (0, context_1.resolveProjectContext)(ctx.cwd);
+        if (!resolved.context)
+            return fail(resolved.reason);
+        try {
+            const schema = await (0, schema_resolve_1.resolveSchema)(resolved.context);
+            const table = (0, schema_resolve_1.resolveTable)(schema, params.table_name);
+            const field = (0, schema_resolve_1.resolveField)(table, params.field_name);
+            await resolved.context.api.field
+                .delete({ where: { id: field.id }, select: { id: true } })
+                .unwrap();
+            return ok(`Deleted field ${params.table_name}.${params.field_name}`);
+        }
+        catch (err) {
+            return fail(err instanceof Error ? err.message : 'Failed to delete field');
+        }
+    },
+};

package/tools/provision-blueprint.d.ts

@@ -0,0 +1,22 @@
+import type { ToolDefinition } from '@earendil-works/pi-coding-agent';
+declare const BlueprintSchema: import("typebox/type").TSchema;
+type ProvisionedField = {
+    name: string;
+    type: string;
+    isRequired: boolean;
+    defaultValue: string | null;
+};
+type ProvisionedTable = {
+    name: string;
+    fields: ProvisionedField[];
+    policies: string[];
+    relationCount: number;
+};
+export type ProvisionBlueprintDetails = {
+    created: number;
+    total: number;
+    tables: ProvisionedTable[];
+    error: string | null;
+};
+export declare const provisionBlueprintTool: ToolDefinition<typeof BlueprintSchema, ProvisionBlueprintDetails>;
+export {};