@agentic-kit/pi 0.17.0 → 0.18.0

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

@@ -1,203 +0,0 @@
-import { z } from 'zod';
-import { resolveProjectContext } from '../context';
-import { toolSchema } from '../tool-schema';
-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 ManageEntityTypesSchema = 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');
-}
-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: ManageEntityTypesSchema,
-    async execute(_id, params, _signal, _onUpdate, 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

@@ -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/esm/tools/mutations.js

@@ -1,235 +0,0 @@
-import { toFieldDefault, toFieldType } from '@agentic-kit/harness';
-import { z } from 'zod';
-import { resolveProjectContext } from '../context';
-import { findUniqueConstraintId, resolveField, resolveSchema, resolveTable } from '../schema-resolve';
-import { toolSchema } from '../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 = z.object({
-    table_name: z.string().describe('Name of the table to delete (snake_case)'),
-});
-const DeleteTableSchema = toolSchema(DeleteTableZod);
-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: DeleteTableSchema,
-    async execute(_id, params, _signal, _onUpdate, 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(),
-});
-const CreateFieldSchema = toolSchema(CreateFieldZod);
-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: CreateFieldSchema,
-    async execute(_id, params, _signal, _onUpdate, 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(),
-});
-const UpdateFieldSchema = toolSchema(UpdateFieldZod);
-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: UpdateFieldSchema,
-    async execute(_id, params, _signal, _onUpdate, 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'),
-});
-const DeleteFieldSchema = toolSchema(DeleteFieldZod);
-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: DeleteFieldSchema,
-    async execute(_id, params, _signal, _onUpdate, 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

@@ -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 {};

package/esm/tools/provision-blueprint.js

@@ -1,111 +0,0 @@
-import { BlueprintZod, expandBlueprintDefaults, filterInternalPolicies, } from '@agentic-kit/harness';
-import { resolveProjectContext } from '../context';
-import { toolSchema } from '../tool-schema';
-const BlueprintSchema = toolSchema(BlueprintZod);
-function formatText(name, details) {
-    if (details.error)
-        return `Failed to provision "${name}": ${details.error}`;
-    const lines = [`Created ${details.created} table${details.created === 1 ? '' : 's'} from "${name}":`];
-    for (const table of details.tables) {
-        const parts = [`${table.fields.length} field${table.fields.length === 1 ? '' : 's'}`];
-        if (table.relationCount > 0) {
-            parts.push(`${table.relationCount} relation${table.relationCount === 1 ? '' : 's'}`);
-        }
-        if (table.policies.length > 0) {
-            parts.push(`policies: ${table.policies.map((policy) => policy.replace(/^Authz/, '')).join(', ')}`);
-        }
-        lines.push(`  - ${table.name} (${parts.join(', ')})`);
-    }
-    return lines.join('\n');
-}
-export const provisionBlueprintTool = {
-    name: 'provision_blueprint',
-    label: 'Provision blueprint',
-    description: 'Create one or more related tables (with fields, RLS policies, and relations) in the project database from a blueprint definition. Always put related tables in a SINGLE call so relations are created together.',
-    promptSnippet: 'provision_blueprint: create new tables from scratch in a single call (fields + policies + relations). Call describe_schema first.',
-    parameters: BlueprintSchema,
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-        const empty = { created: 0, total: 0, tables: [], error: null };
-        const resolved = await resolveProjectContext(ctx.cwd);
-        if (!resolved.context) {
-            return { content: [{ type: 'text', text: resolved.reason }], details: empty };
-        }
-        const { modules, databaseId, schemaId, ownerId } = resolved.context;
-        if (!ownerId) {
-            return {
-                content: [{ type: 'text', text: 'Not authenticated (missing OWNER_ID in .env).' }],
-                details: empty,
-            };
-        }
-        const definition = expandBlueprintDefaults(params.definition);
-        const uniqueName = `${params.name}_${Date.now()}`;
-        try {
-            const createResult = await modules.blueprint
-                .create({
-                data: {
-                    ownerId,
-                    databaseId,
-                    name: uniqueName,
-                    displayName: params.name,
-                    description: params.description,
-                    definition,
-                },
-                select: { id: true, name: true },
-            })
-                .unwrap();
-            const blueprintId = createResult.createBlueprint?.blueprint?.id;
-            if (!blueprintId)
-                throw new Error('Failed to create blueprint');
-            const constructResult = await modules.mutation
-                .constructBlueprint({ input: { blueprintId, schemaId } }, { select: { result: true } })
-                .unwrap();
-            const result = constructResult.constructBlueprint?.result;
-            if (!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';
-                const details = {
-                    created: 0,
-                    total: params.definition.tables.length,
-                    tables: [],
-                    error: typeof error === 'string' ? error : JSON.stringify(error),
-                };
-                return { content: [{ type: 'text', text: formatText(params.name, details) }], details };
-            }
-            const relations = params.definition.relations ?? [];
-            const details = {
-                created: params.definition.tables.length,
-                total: params.definition.tables.length,
-                tables: params.definition.tables.map((t) => ({
-                    name: t.table_name,
-                    fields: (t.fields ?? []).map((f) => ({
-                        name: f.name,
-                        type: f.type,
-                        isRequired: f.is_required ?? false,
-                        defaultValue: f.default ?? null,
-                    })),
-                    policies: filterInternalPolicies(t.policies.map((p) => p.$type)),
-                    relationCount: relations.filter((r) => r.source_table === t.table_name).length,
-                })),
-                error: null,
-            };
-            return { content: [{ type: 'text', text: formatText(params.name, details) }], details };
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : 'Failed to provision blueprint';
-            const details = {
-                created: 0,
-                total: params.definition.tables.length,
-                tables: [],
-                error: message,
-            };
-            return { content: [{ type: 'text', text: formatText(params.name, details) }], details };
-        }
-    },
-};

package/esm/tools/provision-database.d.ts

@@ -1,14 +0,0 @@
-import type { ToolDefinition } from '@earendil-works/pi-coding-agent';
-declare const ProvisionDatabaseSchema: import("typebox/type").TSchema;
-export type ProvisionDatabaseDetails = {
-    success: boolean;
-    message: string;
-    databaseId?: string;
-    databaseName?: string;
-    ownerId?: string;
-    fixupNote?: string;
-    /** True when an existing live binding was kept — nothing changed. */
-    skipped?: boolean;
-};
-export declare const provisionDatabaseTool: ToolDefinition<typeof ProvisionDatabaseSchema, ProvisionDatabaseDetails>;
-export {};