@agentic-kit/db-tools 0.2.0

package/esm/tools/describe-schema.d.ts

@@ -0,0 +1,19 @@
+import { type HarnessTool } from '@agentic-kit/harness';
+import { z } from 'zod';
+declare const ParamZod: z.ZodObject<{}, z.core.$strip>;
+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: HarnessTool<typeof ParamZod, DescribeSchemaDetails>;
+export {};

package/esm/tools/describe-schema.js

@@ -0,0 +1,130 @@
+import { fieldTypeToTypeName, isInternalPolicy } from '@agentic-kit/harness';
+import { z } from 'zod';
+import { resolveProjectContext } from '../context';
+const ParamZod = z.object({});
+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');
+}
+export const 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: ParamZod,
+    async execute(_params, ctx) {
+        const resolved = await 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: 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 (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/esm/tools/manage-entity-types.d.ts

@@ -0,0 +1,40 @@
+import type { HarnessTool } from '@agentic-kit/harness';
+import { z } from 'zod';
+declare const ManageEntityTypesZod: z.ZodObject<{
+    action: z.ZodEnum<{
+        create: "create";
+        delete: "delete";
+        list: "list";
+    }>;
+    name: z.ZodOptional<z.ZodString>;
+    entity_type_id: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    prefix: z.ZodOptional<z.ZodString>;
+    parent_entity: z.ZodOptional<z.ZodString>;
+    is_visible: z.ZodOptional<z.ZodBoolean>;
+    has_invites: z.ZodOptional<z.ZodBoolean>;
+    has_profiles: z.ZodOptional<z.ZodBoolean>;
+    has_limits: z.ZodOptional<z.ZodBoolean>;
+    has_levels: z.ZodOptional<z.ZodBoolean>;
+    has_storage: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type EntityTypeSummary = {
+    id: string;
+    name: string | null;
+    description: string | null;
+    prefix: string | null;
+    parentEntity: string | null;
+    isVisible: boolean | null;
+    entityTableName: string | null;
+    installedModules: string[] | null;
+};
+export type ManageEntityTypesDetails = {
+    success: boolean;
+    message: string;
+    entityTypes?: EntityTypeSummary[];
+};
+export declare function defaultPrefix(name: string): string;
+type Params = z.infer<typeof ManageEntityTypesZod>;
+export declare function validateManageEntityTypes(params: Params): string | null;
+export declare const manageEntityTypesTool: HarnessTool<typeof ManageEntityTypesZod, ManageEntityTypesDetails>;
+export {};

package/esm/tools/manage-entity-types.js

@@ -0,0 +1,201 @@
+import { z } from 'zod';
+import { resolveProjectContext } from '../context';
+const ManageEntityTypesZod = z.object({
+    action: z
+        .enum(['list', 'create', 'delete'])
+        .describe('list: show the entity types provisioned in this database. create: provision a new entity type (creates its entity table + membership wiring). delete: remove the provision registration. Registrations are immutable once provisioned — there is no update; to change one, delete it and create a new one.'),
+    name: z.string().describe('Entity type name. Required for create.').optional(),
+    entity_type_id: z
+        .string()
+        .describe('Entity type provision id. Required for delete — get it from action "list".')
+        .optional(),
+    description: z
+        .string()
+        .describe('Human-readable description of the entity type. Create only.')
+        .optional(),
+    prefix: z
+        .string()
+        .describe('Table-name prefix for the provisioned tables (e.g. "org" → org table, org_memberships). Create only; defaults to the snake_case of name.')
+        .optional(),
+    parent_entity: z
+        .string()
+        .describe('Parent entity table name, for hierarchical types (e.g. a "team" under an "org"). Create only; the backend defaults it to the root entity (org).')
+        .optional(),
+    is_visible: z
+        .boolean()
+        .describe('Whether the type shows up in end-user entity listings. Create only.')
+        .optional(),
+    has_invites: z
+        .boolean()
+        .describe('Provision an invites module ({prefix}_invites + claimed invites). Create only.')
+        .optional(),
+    has_profiles: z
+        .boolean()
+        .describe('Provision a profiles table for members of this type. Create only.')
+        .optional(),
+    has_limits: z
+        .boolean()
+        .describe('Provision usage-limits tracking for this type. Create only.')
+        .optional(),
+    has_levels: z
+        .boolean()
+        .describe('Provision levels/achievements support for this type. Create only.')
+        .optional(),
+    has_storage: z
+        .boolean()
+        .describe('Provision a storage module (files + buckets tables) for this type. Create only.')
+        .optional(),
+});
+const SUMMARY_SELECT = {
+    id: true,
+    name: true,
+    description: true,
+    prefix: true,
+    parentEntity: true,
+    isVisible: true,
+    outEntityTableName: true,
+    outInstalledModules: true,
+};
+function toSummary(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        description: row.description,
+        prefix: row.prefix,
+        parentEntity: row.parentEntity,
+        isVisible: row.isVisible,
+        entityTableName: row.outEntityTableName,
+        installedModules: row.outInstalledModules,
+    };
+}
+function formatSummary(s) {
+    const parts = [
+        `- ${s.name ?? '?'} (id: ${s.id})`,
+        `  table: ${s.entityTableName ?? '?'}, prefix: ${s.prefix ?? '?'}`,
+    ];
+    if (s.parentEntity)
+        parts.push(`  parent: ${s.parentEntity}`);
+    if (s.description)
+        parts.push(`  description: ${s.description}`);
+    if (s.installedModules?.length)
+        parts.push(`  modules: ${s.installedModules.join(', ')}`);
+    return parts.join('\n');
+}
+export function defaultPrefix(name) {
+    return name
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '');
+}
+export function validateManageEntityTypes(params) {
+    switch (params.action) {
+        case 'create':
+            if (!params.name?.trim())
+                return 'create requires "name".';
+            if (params.entity_type_id)
+                return 'create does not take "entity_type_id" — it mints a new one.';
+            return null;
+        case 'delete':
+            if (!params.entity_type_id)
+                return 'delete requires "entity_type_id" (use action "list" to find it).';
+            return null;
+        default:
+            return null;
+    }
+}
+export const manageEntityTypesTool = {
+    name: 'manage_entity_types',
+    label: 'Manage entity types',
+    description: 'List, create, or delete entity types in the project database. An entity type (e.g. organization, team, project) provisions its own entity table plus membership wiring, and is the unit that API keys can be scoped to. Registrations are immutable once provisioned — to change one, delete it and create a new one. Deleting removes the registration; the already-provisioned entity table stays in the API schema.',
+    promptSnippet: 'manage_entity_types: list/create/delete entity types (orgs, teams, …) in the project database. list is free; create/delete are gated.',
+    parameters: ManageEntityTypesZod,
+    async execute(params, ctx) {
+        const resolved = await resolveProjectContext(ctx.cwd);
+        if (!resolved.context) {
+            return {
+                content: [{ type: 'text', text: resolved.reason }],
+                details: { success: false, message: resolved.reason },
+            };
+        }
+        const invalid = validateManageEntityTypes(params);
+        if (invalid) {
+            return {
+                content: [{ type: 'text', text: invalid }],
+                details: { success: false, message: invalid },
+            };
+        }
+        const { modules, databaseId } = resolved.context;
+        try {
+            switch (params.action) {
+                case 'list': {
+                    const result = await modules.entityTypeProvision
+                        .findMany({
+                        where: { databaseId: { equalTo: databaseId } },
+                        select: SUMMARY_SELECT,
+                    })
+                        .unwrap();
+                    const entityTypes = result.entityTypeProvisions.nodes.map((row) => toSummary(row));
+                    const message = entityTypes.length === 0
+                        ? 'No entity types are provisioned in this database yet.'
+                        : `${entityTypes.length} entity type${entityTypes.length === 1 ? '' : 's'}:\n${entityTypes.map(formatSummary).join('\n')}`;
+                    return {
+                        content: [{ type: 'text', text: message }],
+                        details: { success: true, message, entityTypes },
+                    };
+                }
+                case 'create': {
+                    const name = params.name.trim();
+                    const result = await modules.entityTypeProvision
+                        .create({
+                        data: {
+                            databaseId,
+                            name,
+                            prefix: params.prefix?.trim() || defaultPrefix(name),
+                            ...(params.description !== undefined && { description: params.description }),
+                            ...(params.parent_entity !== undefined && { parentEntity: params.parent_entity }),
+                            ...(params.is_visible !== undefined && { isVisible: params.is_visible }),
+                            ...(params.has_invites !== undefined && { hasInvites: params.has_invites }),
+                            ...(params.has_profiles !== undefined && { hasProfiles: params.has_profiles }),
+                            ...(params.has_limits !== undefined && { hasLimits: params.has_limits }),
+                            ...(params.has_levels !== undefined && { hasLevels: params.has_levels }),
+                            ...(params.has_storage && {
+                                storage: [{}],
+                            }),
+                        },
+                        select: SUMMARY_SELECT,
+                    })
+                        .unwrap();
+                    const row = result.createEntityTypeProvision?.entityTypeProvision;
+                    if (!row)
+                        throw new Error('createEntityTypeProvision returned no row.');
+                    const summary = toSummary(row);
+                    const message = `Created entity type "${summary.name}" (id: ${summary.id}) — entity table "${summary.entityTableName}"${summary.installedModules?.length ? `, modules: ${summary.installedModules.join(', ')}` : ''}. Run run_codegen to pull it into the typed SDK.`;
+                    return {
+                        content: [{ type: 'text', text: message }],
+                        details: { success: true, message, entityTypes: [summary] },
+                    };
+                }
+                case 'delete': {
+                    const result = await modules.entityTypeProvision
+                        .delete({
+                        where: { id: params.entity_type_id },
+                        select: { id: true, name: true, outEntityTableName: true },
+                    })
+                        .unwrap();
+                    const row = result.deleteEntityTypeProvision?.entityTypeProvision;
+                    const name = row?.name ?? params.entity_type_id;
+                    const message = `Deleted entity type registration "${name}". Note: the provisioned entity table${row?.outEntityTableName ? ` "${row.outEntityTableName}"` : ''} remains in the API schema with its data.`;
+                    return {
+                        content: [{ type: 'text', text: message }],
+                        details: { success: true, message },
+                    };
+                }
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Failed to manage entity types';
+            return { content: [{ type: 'text', text: message }], details: { success: false, message } };
+        }
+    },
+};

package/esm/tools/mutations.d.ts

@@ -0,0 +1,35 @@
+import { type HarnessTool } from '@agentic-kit/harness';
+import { z } from 'zod';
+export type MutationDetails = {
+    success: boolean;
+    message: string;
+};
+declare const DeleteTableZod: z.ZodObject<{
+    table_name: z.ZodString;
+}, z.core.$strip>;
+export declare const deleteTableTool: HarnessTool<typeof DeleteTableZod, MutationDetails>;
+declare const CreateFieldZod: z.ZodObject<{
+    table_name: z.ZodString;
+    field_name: z.ZodString;
+    type: z.ZodString;
+    is_required: z.ZodOptional<z.ZodBoolean>;
+    default_value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+    is_unique: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const createFieldTool: HarnessTool<typeof CreateFieldZod, MutationDetails>;
+declare const UpdateFieldZod: z.ZodObject<{
+    table_name: z.ZodString;
+    field_name: z.ZodString;
+    new_name: z.ZodOptional<z.ZodString>;
+    new_type: z.ZodOptional<z.ZodString>;
+    is_required: z.ZodOptional<z.ZodBoolean>;
+    default_value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+    is_unique: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const updateFieldTool: HarnessTool<typeof UpdateFieldZod, MutationDetails>;
+declare const DeleteFieldZod: z.ZodObject<{
+    table_name: z.ZodString;
+    field_name: z.ZodString;
+}, z.core.$strip>;
+export declare const deleteFieldTool: HarnessTool<typeof DeleteFieldZod, MutationDetails>;
+export {};

package/esm/tools/mutations.js

@@ -0,0 +1,230 @@
+import { toFieldDefault, toFieldType } from '@agentic-kit/harness';
+import { z } from 'zod';
+import { resolveProjectContext } from '../context';
+import { findUniqueConstraintId, resolveField, resolveSchema, resolveTable } from '../schema-resolve';
+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 = z.object({
+    table_name: z.string().describe('Name of the table to delete (snake_case)'),
+});
+export const 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: DeleteTableZod,
+    async execute(params, ctx) {
+        const resolved = await resolveProjectContext(ctx.cwd);
+        if (!resolved.context)
+            return fail(resolved.reason);
+        try {
+            const schema = await resolveSchema(resolved.context);
+            const table = 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 = z.object({
+    table_name: z.string().describe('Name of the table to add the field to'),
+    field_name: z.string().describe('Field name in snake_case'),
+    type: z
+        .string()
+        .describe('PostgreSQL type: text, integer, smallint, numeric, boolean, date, timestamp, timestamptz, time, json, jsonb, inet, email, url, image, upload'),
+    is_required: z.boolean().describe('Whether the field is NOT NULL. Defaults to false.').optional(),
+    default_value: z
+        .union([z.string(), z.null()])
+        .describe('SQL default expression, e.g. "now()", "\'draft\'"')
+        .optional(),
+    is_unique: z
+        .boolean()
+        .describe('Whether the field has a unique constraint. Defaults to false.')
+        .optional(),
+});
+export const 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: CreateFieldZod,
+    async execute(params, ctx) {
+        const resolved = await resolveProjectContext(ctx.cwd);
+        if (!resolved.context)
+            return fail(resolved.reason);
+        const { api, databaseId } = resolved.context;
+        try {
+            const schema = await resolveSchema(resolved.context);
+            const table = resolveTable(schema, params.table_name);
+            const result = await api.field
+                .create({
+                data: {
+                    name: params.field_name,
+                    type: toFieldType(params.type),
+                    tableId: table.id,
+                    databaseId,
+                    isRequired: params.is_required ?? false,
+                    defaultValue: 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 = z.object({
+    table_name: z.string().describe('Name of the table containing the field'),
+    field_name: z.string().describe('Current field name'),
+    new_name: z.string().describe('New field name in snake_case (if renaming)').optional(),
+    new_type: z.string().describe('New PostgreSQL type (if changing type)').optional(),
+    is_required: z.boolean().describe('Set NOT NULL constraint').optional(),
+    default_value: z
+        .union([z.string(), z.null()])
+        .describe('New SQL default expression, or null to remove')
+        .optional(),
+    is_unique: z.boolean().describe('Set or remove unique constraint').optional(),
+});
+export const 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: UpdateFieldZod,
+    async execute(params, ctx) {
+        const resolved = await resolveProjectContext(ctx.cwd);
+        if (!resolved.context)
+            return fail(resolved.reason);
+        const { api, databaseId } = resolved.context;
+        try {
+            const schema = await resolveSchema(resolved.context);
+            const table = resolveTable(schema, params.table_name);
+            const field = resolveField(table, params.field_name);
+            const patch = {};
+            if (params.new_name)
+                patch.name = params.new_name;
+            if (params.new_type)
+                patch.type = 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 : (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 = 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 = z.object({
+    table_name: z.string().describe('Name of the table containing the field'),
+    field_name: z.string().describe('Name of the field to delete'),
+});
+export const 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: DeleteFieldZod,
+    async execute(params, ctx) {
+        const resolved = await resolveProjectContext(ctx.cwd);
+        if (!resolved.context)
+            return fail(resolved.reason);
+        try {
+            const schema = await resolveSchema(resolved.context);
+            const table = resolveTable(schema, params.table_name);
+            const field = 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/esm/tools/provision-blueprint.d.ts

@@ -0,0 +1,21 @@
+import { BlueprintZod, type HarnessTool } from '@agentic-kit/harness';
+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: HarnessTool<typeof BlueprintZod, ProvisionBlueprintDetails>;
+export {};