@agentic-kit/pi 0.17.0 → 0.18.0

package/tools/describe-schema.js

@@ -1,135 +0,0 @@
-"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/manage-entity-types.d.ts

@@ -1,41 +0,0 @@
-import type { ToolDefinition } from '@earendil-works/pi-coding-agent';
-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>;
-declare const ManageEntityTypesSchema: import("typebox/type").TSchema;
-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: ToolDefinition<typeof ManageEntityTypesSchema, ManageEntityTypesDetails>;
-export {};

package/tools/manage-entity-types.js

@@ -1,208 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.manageEntityTypesTool = void 0;
-exports.defaultPrefix = defaultPrefix;
-exports.validateManageEntityTypes = validateManageEntityTypes;
-const zod_1 = require("zod");
-const context_1 = require("../context");
-const tool_schema_1 = require("../tool-schema");
-const ManageEntityTypesZod = zod_1.z.object({
-    action: zod_1.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: zod_1.z.string().describe('Entity type name. Required for create.').optional(),
-    entity_type_id: zod_1.z
-        .string()
-        .describe('Entity type provision id. Required for delete — get it from action "list".')
-        .optional(),
-    description: zod_1.z
-        .string()
-        .describe('Human-readable description of the entity type. Create only.')
-        .optional(),
-    prefix: zod_1.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: zod_1.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: zod_1.z
-        .boolean()
-        .describe('Whether the type shows up in end-user entity listings. Create only.')
-        .optional(),
-    has_invites: zod_1.z
-        .boolean()
-        .describe('Provision an invites module ({prefix}_invites + claimed invites). Create only.')
-        .optional(),
-    has_profiles: zod_1.z
-        .boolean()
-        .describe('Provision a profiles table for members of this type. Create only.')
-        .optional(),
-    has_limits: zod_1.z
-        .boolean()
-        .describe('Provision usage-limits tracking for this type. Create only.')
-        .optional(),
-    has_levels: zod_1.z
-        .boolean()
-        .describe('Provision levels/achievements support for this type. Create only.')
-        .optional(),
-    has_storage: zod_1.z
-        .boolean()
-        .describe('Provision a storage module (files + buckets tables) for this type. Create only.')
-        .optional(),
-});
-const ManageEntityTypesSchema = (0, tool_schema_1.toolSchema)(ManageEntityTypesZod);
-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');
-}
-function defaultPrefix(name) {
-    return name
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '_')
-        .replace(/^_+|_+$/g, '');
-}
-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;
-    }
-}
-exports.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: ManageEntityTypesSchema,
-    async execute(_id, params, _signal, _onUpdate, ctx) {
-        const resolved = await (0, context_1.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/tools/mutations.d.ts

@@ -1,14 +0,0 @@
-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

@@ -1,238 +0,0 @@
-"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

@@ -1,22 +0,0 @@
-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 {};