@agentic-kit/pi 0.17.1 → 0.18.1

package/esm/records/meta.d.ts

@@ -1,41 +0,0 @@
-import type { Table, TableInflection } from '@constructive-io/graphql-query/types/schema';
-export declare const META_QUERY = "\n  query DbToolsMeta {\n    _meta {\n      tables {\n        name\n        query { all one create update delete }\n        inflection {\n          allRows\n          conditionType\n          connection\n          createInputType\n          createPayloadType\n          deletePayloadType\n          edge\n          filterType\n          orderByType\n          patchType\n          tableType\n          updatePayloadType\n        }\n        fields {\n          name\n          isNotNull\n          hasDefault\n          type {\n            gqlType\n            isArray\n            pgType\n            subtype\n            isNotNull\n            hasDefault\n          }\n        }\n      }\n    }\n  }\n";
-type RawType = {
-    gqlType: string;
-    isArray: boolean;
-    modifier?: string | number | null;
-    pgAlias?: string | null;
-    pgType?: string | null;
-    subtype?: string | null;
-    typmod?: number | null;
-    isNotNull?: boolean | null;
-    hasDefault?: boolean | null;
-};
-type RawField = {
-    name: string;
-    isNotNull?: boolean | null;
-    hasDefault?: boolean | null;
-    type: RawType;
-};
-type RawInflection = Partial<Record<keyof TableInflection, string | null>>;
-type RawQuery = {
-    all: string | null;
-    one?: string | null;
-    create?: string | null;
-    update?: string | null;
-    delete?: string | null;
-};
-export type RawMetaTable = {
-    name: string;
-    query?: RawQuery | null;
-    inflection?: RawInflection | null;
-    fields?: (RawField | null)[] | null;
-};
-export type MetaResponse = {
-    _meta?: {
-        tables?: (RawMetaTable | null)[] | null;
-    } | null;
-};
-export declare function cleanTable(meta: RawMetaTable): Table;
-export declare function findMetaTable(tables: RawMetaTable[], requested: string): RawMetaTable | undefined;
-export {};

package/esm/records/meta.js

@@ -1,167 +0,0 @@
-// Vendored from constructive-client's `@constructive-io/data` (not published to
-// the registry). We query the per-DB data endpoint's `_meta` introspection and
-// reshape each table into the `Table` shape `buildPostGraphileCreate` expects.
-// Relations are intentionally left empty: the create-mutation builder only reads
-// them to skip relational fields in the return selection, and every `_meta` field
-// is a real scalar column, so selecting them all is valid.
-//
-// Only fields the live backend's `_meta` actually exposes are selected here —
-// over-selecting (e.g. MetaType.modifier or MetaInflection.createField) fails
-// GraphQL validation. The reshapers below tolerate the omitted fields.
-export const META_QUERY = `
-  query DbToolsMeta {
-    _meta {
-      tables {
-        name
-        query { all one create update delete }
-        inflection {
-          allRows
-          conditionType
-          connection
-          createInputType
-          createPayloadType
-          deletePayloadType
-          edge
-          filterType
-          orderByType
-          patchType
-          tableType
-          updatePayloadType
-        }
-        fields {
-          name
-          isNotNull
-          hasDefault
-          type {
-            gqlType
-            isArray
-            pgType
-            subtype
-            isNotNull
-            hasDefault
-          }
-        }
-      }
-    }
-  }
-`;
-function convertInflection(inflection) {
-    if (!inflection)
-        return undefined;
-    const s = (key) => inflection[key] ?? '';
-    const n = (key) => inflection[key] ?? null;
-    return {
-        allRows: s('allRows'),
-        allRowsSimple: s('allRowsSimple'),
-        conditionType: s('conditionType'),
-        connection: s('connection'),
-        createField: s('createField'),
-        createInputType: s('createInputType'),
-        createPayloadType: s('createPayloadType'),
-        deleteByPrimaryKey: n('deleteByPrimaryKey'),
-        deletePayloadType: s('deletePayloadType'),
-        edge: s('edge'),
-        edgeField: s('edgeField'),
-        enumType: s('enumType'),
-        filterType: n('filterType'),
-        inputType: s('inputType'),
-        orderByType: s('orderByType'),
-        patchField: s('patchField'),
-        patchType: n('patchType'),
-        tableFieldName: s('tableFieldName'),
-        tableType: s('tableType'),
-        typeName: s('typeName'),
-        updateByPrimaryKey: n('updateByPrimaryKey'),
-        updatePayloadType: n('updatePayloadType'),
-    };
-}
-function convertQuery(query) {
-    if (!query)
-        return undefined;
-    return {
-        all: query.all ?? '',
-        one: query.one ?? null,
-        create: query.create ?? '',
-        update: query.update ?? null,
-        delete: query.delete ?? null,
-    };
-}
-export function cleanTable(meta) {
-    return {
-        name: meta.name,
-        inflection: convertInflection(meta.inflection),
-        query: convertQuery(meta.query),
-        fields: (meta.fields ?? [])
-            .filter((f) => Boolean(f))
-            .map((field) => ({
-            name: field.name,
-            type: {
-                gqlType: field.type.gqlType,
-                isArray: field.type.isArray,
-                modifier: field.type.modifier,
-                pgAlias: field.type.pgAlias,
-                pgType: field.type.pgType,
-                subtype: field.type.subtype,
-                typmod: field.type.typmod,
-            },
-            isNotNull: field.isNotNull ?? field.type.isNotNull ?? null,
-            hasDefault: field.hasDefault ?? field.type.hasDefault ?? null,
-        })),
-        relations: { belongsTo: [], hasOne: [], hasMany: [], manyToMany: [] },
-    };
-}
-function normalizeTableLookupKey(value) {
-    return (value ?? '')
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]/g, '');
-}
-function getTableLookupVariants(value) {
-    const normalized = normalizeTableLookupKey(value);
-    if (!normalized)
-        return [];
-    const variants = new Set([normalized]);
-    if (normalized.endsWith('y')) {
-        variants.add(`${normalized}s`);
-        variants.add(`${normalized.slice(0, -1)}ies`);
-    }
-    if (normalized.endsWith('ies')) {
-        variants.add(`${normalized.slice(0, -3)}y`);
-    }
-    if (/(s|x|z|ch|sh)$/.test(normalized))
-        variants.add(`${normalized}es`);
-    if (normalized.endsWith('es'))
-        variants.add(normalized.slice(0, -2));
-    if (!normalized.endsWith('s'))
-        variants.add(`${normalized}s`);
-    if (normalized.endsWith('s'))
-        variants.add(normalized.slice(0, -1));
-    return [...variants].filter(Boolean);
-}
-// Resolve a user-supplied table name (snake_case singular or plural) against the
-// PascalCase-singular `_meta` table names, tolerating pluralization differences.
-export function findMetaTable(tables, requested) {
-    const index = new Map();
-    for (const table of tables) {
-        const keys = [
-            table.name,
-            table.query?.all,
-            table.query?.one,
-            table.inflection?.tableType,
-            table.inflection?.tableFieldName,
-            table.inflection?.allRows,
-        ];
-        for (const key of keys) {
-            for (const variant of getTableLookupVariants(key)) {
-                if (!index.has(variant))
-                    index.set(variant, table);
-            }
-        }
-    }
-    for (const variant of getTableLookupVariants(requested)) {
-        const match = index.get(variant);
-        if (match)
-            return match;
-    }
-    return undefined;
-}

package/esm/run-codegen/barrels.d.ts

@@ -1,3 +0,0 @@
-/** Rewrite directory barrel specifiers under `root` in place. Returns the count
- * of files changed. No-op (returns 0) when `root` does not exist. */
-export declare function normalizeSdkBarrels(root: string): number;

package/esm/run-codegen/barrels.js

@@ -1,48 +0,0 @@
-// Turbopack barrel normalization (TURBOPACK-BARREL-001).
-//
-// Codegen emits directory barrel re-exports like `export * from './hooks'` where
-// `./hooks` is a directory with an index.ts. Next.js 16's Turbopack cannot
-// resolve directory specifiers — it needs an explicit `./hooks/index`. This pass
-// rewrites `./X` -> `./X/index` only when X resolves to a sibling DIRECTORY,
-// leaving file specifiers (and ones already ending in /index) untouched.
-//
-// Pure-ish: operates on a real directory tree (so it's exercised with a temp
-// fixture in tests) and is idempotent — safe to re-run.
-import fs from 'node:fs';
-import path from 'node:path';
-const SPEC_RE = /((?:export|import)[^\n]*?from\s*["'])(\.\.?\/[^"']+?)(["'])/g;
-const FILE_EXT_RE = /\.(tsx?|jsx?|json|css)$/;
-/** Rewrite directory barrel specifiers under `root` in place. Returns the count
- * of files changed. No-op (returns 0) when `root` does not exist. */
-export function normalizeSdkBarrels(root) {
-    if (!fs.existsSync(root))
-        return 0;
-    let changed = 0;
-    const walk = (dir) => {
-        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-            const p = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                walk(p);
-                continue;
-            }
-            if (!/\.tsx?$/.test(entry.name))
-                continue;
-            const orig = fs.readFileSync(p, 'utf8');
-            const next = orig.replace(SPEC_RE, (match, pre, spec, post) => {
-                if (FILE_EXT_RE.test(spec))
-                    return match; // already a file
-                const abs = path.resolve(path.dirname(p), spec);
-                if (fs.existsSync(abs) && fs.statSync(abs).isDirectory()) {
-                    return pre + spec.replace(/\/$/, '') + '/index' + post;
-                }
-                return match;
-            });
-            if (next !== orig) {
-                fs.writeFileSync(p, next);
-                changed++;
-            }
-        }
-    };
-    walk(root);
-    return changed;
-}

package/esm/run-codegen/endpoints.d.ts

@@ -1,8 +0,0 @@
-export type PlaneEndpoints = {
-    admin: string;
-    auth: string;
-    app: string;
-};
-export declare function derivePlaneEndpoints(apiEndpoint: string, databaseName: string): PlaneEndpoints | undefined;
-export declare function codegenEndpointEnv(planes: PlaneEndpoints): Record<string, string>;
-export declare function envLocalContent(databaseName: string, planes: PlaneEndpoints | undefined): string;

package/esm/run-codegen/endpoints.js

@@ -1,46 +0,0 @@
-// Codegen and the Next.js dev server default every per-DB vhost to
-// *-<db>.localhost:3000, which only exists on a local backend. Derive the real
-// vhosts from the api endpoint the binding belongs to by swapping its first
-// host label (api.launchql.dev -> admin-<db>.launchql.dev) — the same scheme
-// context.ts uses for the data plane. The app DATA plane is `api-<db>`, not
-// `app-<db>` (SUBDOMAIN-001).
-export function derivePlaneEndpoints(apiEndpoint, databaseName) {
-    const derive = (label) => {
-        try {
-            const url = new URL(apiEndpoint);
-            const labels = url.hostname.split('.');
-            labels[0] = `${label}-${databaseName}`;
-            url.hostname = labels.join('.');
-            return url.toString();
-        }
-        catch {
-            return undefined;
-        }
-    };
-    const admin = derive('admin');
-    const auth = derive('auth');
-    const app = derive('api');
-    return admin && auth && app ? { admin, auth, app } : undefined;
-}
-// The template's graphql-codegen.config.ts honors CODEGEN_*_ENDPOINT for the
-// URL and CODEGEN_*_HOST for the Host header; set both so scheme and routing
-// stay in sync on any backend.
-export function codegenEndpointEnv(planes) {
-    return {
-        CODEGEN_ADMIN_ENDPOINT: planes.admin,
-        CODEGEN_ADMIN_HOST: new URL(planes.admin).host,
-        CODEGEN_AUTH_ENDPOINT: planes.auth,
-        CODEGEN_AUTH_HOST: new URL(planes.auth).host,
-        CODEGEN_APP_ENDPOINT: planes.app,
-        CODEGEN_APP_HOST: new URL(planes.app).host,
-    };
-}
-// .env.local for the dev server: the template's runtime config falls back to
-// localhost vhosts unless NEXT_PUBLIC_*_ENDPOINT overrides are present.
-export function envLocalContent(databaseName, planes) {
-    const lines = [`NEXT_PUBLIC_DB_NAME=${databaseName}`];
-    if (planes) {
-        lines.push(`NEXT_PUBLIC_ADMIN_ENDPOINT=${planes.admin}`, `NEXT_PUBLIC_AUTH_ENDPOINT=${planes.auth}`, `NEXT_PUBLIC_APP_ENDPOINT=${planes.app}`);
-    }
-    return `${lines.join('\n')}\n`;
-}

package/esm/schema-resolve.d.ts

@@ -1,23 +0,0 @@
-import type { ProjectContext } from './context';
-export type ResolvedField = {
-    id: string;
-    name: string;
-    tableId: string;
-};
-export type ResolvedUniqueConstraint = {
-    id: string;
-    fieldIds: string[];
-};
-export type ResolvedTable = {
-    id: string;
-    name: string;
-    fields: ResolvedField[];
-    uniqueConstraints: ResolvedUniqueConstraint[];
-};
-export type ResolvedSchema = {
-    tables: ResolvedTable[];
-};
-export declare function resolveSchema(context: ProjectContext): Promise<ResolvedSchema>;
-export declare function resolveTable(schema: ResolvedSchema, tableName: string): ResolvedTable;
-export declare function resolveField(table: ResolvedTable, fieldName: string): ResolvedField;
-export declare function findUniqueConstraintId(table: ResolvedTable, fieldId: string): string | undefined;

package/esm/schema-resolve.js

@@ -1,69 +0,0 @@
-export async function resolveSchema(context) {
-    const { api, databaseId } = context;
-    const tablesResult = await api.table
-        .findMany({
-        select: { id: true, name: true },
-        where: { databaseId: { equalTo: databaseId } },
-    })
-        .execute();
-    if (!tablesResult.ok) {
-        const message = tablesResult.errors.map((e) => e.message).join('; ');
-        throw new Error(`Failed to read tables: ${message}`);
-    }
-    const tableNodes = tablesResult.data.tables?.nodes ?? [];
-    const tableIds = tableNodes.map((t) => t.id);
-    const fieldsByTable = new Map();
-    const constraintsByTable = new Map();
-    if (tableIds.length > 0) {
-        const fieldsResult = await api.field
-            .findMany({
-            select: { id: true, name: true, tableId: true },
-            where: { tableId: { in: tableIds } },
-        })
-            .execute();
-        if (!fieldsResult.ok) {
-            const message = fieldsResult.errors.map((e) => e.message).join('; ');
-            throw new Error(`Failed to read fields: ${message}`);
-        }
-        for (const field of fieldsResult.data.fields?.nodes ?? []) {
-            const list = fieldsByTable.get(field.tableId) ?? [];
-            list.push({ id: field.id, name: field.name, tableId: field.tableId });
-            fieldsByTable.set(field.tableId, list);
-        }
-        const constraintsResult = await api.uniqueConstraint
-            .findMany({
-            select: { id: true, tableId: true, fieldIds: true },
-            where: { tableId: { in: tableIds } },
-        })
-            .execute();
-        if (constraintsResult.ok) {
-            for (const c of constraintsResult.data.uniqueConstraints?.nodes ?? []) {
-                const list = constraintsByTable.get(c.tableId) ?? [];
-                list.push({ id: c.id, fieldIds: Array.isArray(c.fieldIds) ? c.fieldIds : [] });
-                constraintsByTable.set(c.tableId, list);
-            }
-        }
-    }
-    const tables = tableNodes.map((table) => ({
-        id: table.id,
-        name: table.name,
-        fields: fieldsByTable.get(table.id) ?? [],
-        uniqueConstraints: constraintsByTable.get(table.id) ?? [],
-    }));
-    return { tables };
-}
-export function resolveTable(schema, tableName) {
-    const table = schema.tables.find((t) => t.name === tableName);
-    if (!table)
-        throw new Error(`Table "${tableName}" not found in current schema`);
-    return table;
-}
-export function resolveField(table, fieldName) {
-    const field = table.fields.find((f) => f.name === fieldName);
-    if (!field)
-        throw new Error(`Field "${fieldName}" not found in table "${table.name}"`);
-    return field;
-}
-export function findUniqueConstraintId(table, fieldId) {
-    return table.uniqueConstraints.find((c) => c.fieldIds.includes(fieldId))?.id;
-}

package/esm/tool-schema.d.ts

@@ -1,3 +0,0 @@
-import type { TSchema } from 'typebox';
-import { z } from 'zod';
-export declare function toolSchema(schema: z.ZodType): TSchema;

package/esm/tool-schema.js

@@ -1,10 +0,0 @@
-import { z } from 'zod';
-// Tool parameter schemas are authored in zod; pi's ToolDefinition wants a
-// typebox TSchema. Structurally a TSchema is just a JSON Schema object, so the
-// draft-7 output of z.toJSONSchema (minus the $schema marker, matching what
-// typebox emits) is cast across the boundary. typebox itself is a type-only
-// import — it never appears in the runtime bundle.
-export function toolSchema(schema) {
-    const { $schema: _$schema, ...rest } = z.toJSONSchema(schema, { target: 'draft-7' });
-    return rest;
-}

package/esm/tools/add-policies.d.ts

@@ -1,8 +0,0 @@
-import type { ToolDefinition } from '@earendil-works/pi-coding-agent';
-declare const AddPoliciesSchema: import("typebox/type").TSchema;
-export type AddPoliciesDetails = {
-    success: boolean;
-    message: string;
-};
-export declare const addPoliciesTool: ToolDefinition<typeof AddPoliciesSchema, AddPoliciesDetails>;
-export {};

package/esm/tools/add-policies.js

@@ -1,96 +0,0 @@
-import { buildNodeData, getPolicyFieldDefaults, getPolicyProvisioningConfig } from '@agentic-kit/harness';
-import { z } from 'zod';
-import { resolveProjectContext } from '../context';
-import { addPoliciesToExistingTable } from '../policy/add-policies-to-table';
-import { resolveSchema, resolveTable } from '../schema-resolve';
-import { toolSchema } from '../tool-schema';
-const DEFAULT_ROLE = 'authenticated';
-const CrudOperationSchema = z.enum(['create', 'read', 'update', 'delete']);
-const PolicyEntrySchema = z.object({
-    policy_type: z
-        .string()
-        .describe('Policy type id. Supported: AuthzAllowAll, AuthzDenyAll, AuthzAppMembership, AuthzDirectOwner, AuthzEntityMembership, AuthzOrgHierarchy, AuthzPublishable (these auto-create columns via their Data* node), AuthzRelatedMemberList, AuthzRelatedEntityMembership. Not supported (use the policies UI): AuthzDirectOwnerAny, AuthzMemberList, AuthzTemporal, AuthzComposite.'),
-    operations: z
-        .array(CrudOperationSchema)
-        .min(1)
-        .describe('CRUD operations the policy applies to: any subset of ["create","read","update","delete"].'),
-    role_name: z
-        .string()
-        .describe('PostgreSQL role the policy applies to. Defaults to "authenticated".')
-        .optional(),
-    is_permissive: z
-        .boolean()
-        .describe('PERMISSIVE (default true) vs RESTRICTIVE — most policies should be permissive.')
-        .optional(),
-    data: z
-        .record(z.string(), z.unknown())
-        .describe('Type-specific shared data. AuthzDirectOwner: { entity_field: "owner_id" }. AuthzAppMembership: { permission?, is_admin?, is_owner? }. Empty object {} for AuthzAllowAll / AuthzDenyAll.')
-        .optional(),
-    node_data: z
-        .record(z.string(), z.unknown())
-        .describe('Optional data for the underlying Data* node (has-module policies only).')
-        .optional(),
-});
-const AddPoliciesZod = z.object({
-    table_name: z
-        .string()
-        .describe('Name of the existing table to attach the policies to. Use describe_schema first to verify it exists.'),
-    policies: z
-        .array(PolicyEntrySchema)
-        .min(1)
-        .describe('One or more policies to add. Each entry becomes one secure_table_provision call.'),
-});
-const AddPoliciesSchema = toolSchema(AddPoliciesZod);
-function buildOperations(roleName, isPermissive) {
-    const config = { roleName, isPermissive, policyData: {}, isCustomized: false };
-    return { create: config, read: config, update: config, delete: config };
-}
-export const addPoliciesTool = {
-    name: 'add_policies',
-    label: 'Add policies',
-    description: 'Add one or more RLS policies to an existing table. Has-module policies (AuthzDirectOwner, AuthzEntityMembership, AuthzOrgHierarchy, AuthzPublishable) auto-create the columns they need — call directly, do not add columns first.',
-    promptSnippet: 'add_policies: attach RLS policies to an existing table (one call can add many). Gated.',
-    parameters: AddPoliciesSchema,
-    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 { modules, databaseId, schemaId } = resolved.context;
-        try {
-            const schema = await resolveSchema(resolved.context);
-            const table = resolveTable(schema, params.table_name);
-            const policies = params.policies.map((entry) => {
-                const config = getPolicyProvisioningConfig(entry.policy_type);
-                const defaults = getPolicyFieldDefaults(entry.policy_type);
-                const mergedData = { ...defaults, ...(entry.data ?? {}) };
-                const nodeData = entry.node_data ?? buildNodeData(entry.policy_type, mergedData);
-                return {
-                    policyType: entry.policy_type,
-                    dataNodeType: config?.dataNodeType,
-                    nodeData,
-                    sharedPolicyData: mergedData,
-                    operations: buildOperations(entry.role_name ?? DEFAULT_ROLE, entry.is_permissive ?? true),
-                    enabledOperations: entry.operations,
-                };
-            });
-            await addPoliciesToExistingTable({
-                client: modules,
-                databaseId,
-                schemaId,
-                tableId: table.id,
-                policies,
-            });
-            const count = params.policies.length;
-            const message = `Added ${count} ${count === 1 ? 'policy' : 'policies'} to ${params.table_name}`;
-            return { content: [{ type: 'text', text: message }], details: { success: true, message } };
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : 'Failed to add policies';
-            return { content: [{ type: 'text', text: message }], details: { success: false, message } };
-        }
-    },
-};

package/esm/tools/add-records.d.ts

@@ -1,14 +0,0 @@
-import type { ToolDefinition } from '@earendil-works/pi-coding-agent';
-export type AddRecordsDetails = {
-    success: boolean;
-    message: string;
-    tableName?: string;
-    columns?: string[];
-    rows?: Record<string, unknown>[];
-    createdCount?: number;
-    asOf?: string;
-    needsAuth?: boolean;
-};
-declare const AddRecordsSchema: import("typebox/type").TSchema;
-export declare const addRecordsTool: ToolDefinition<typeof AddRecordsSchema, AddRecordsDetails>;
-export {};

package/esm/tools/add-records.js

@@ -1,124 +0,0 @@
-import { buildPostGraphileCreate, toCamelCaseSingular, toCreateMutationName, } from '@constructive-io/graphql-query/generators';
-import { objects } from '@constructive-io/sdk';
-import { z } from 'zod';
-import { resolveDataToken, resolveProjectContext } from '../context';
-import { cleanTable, findMetaTable, META_QUERY } from '../records/meta';
-import { toolSchema } from '../tool-schema';
-function fail(message) {
-    return { content: [{ type: 'text', text: message }], details: { success: false, message } };
-}
-function needsAuth(message) {
-    return {
-        content: [{ type: 'text', text: message }],
-        details: { success: false, message, needsAuth: true },
-    };
-}
-// Mirror @constructive-io/data's prepareCreateInput (create semantics): drop
-// undefined/null/empty-string so server defaults apply; keep false/0/[]/objects.
-function stripForCreate(record) {
-    const out = {};
-    for (const [key, value] of Object.entries(record)) {
-        if (value === undefined || value === null || value === '')
-            continue;
-        out[key] = value;
-    }
-    return out;
-}
-const AddRecordsZod = z.object({
-    table_name: z
-        .string()
-        .describe('Name of the table to insert rows into (snake_case, singular or plural).'),
-    records: z
-        .array(z.record(z.string(), z.unknown()))
-        .describe('Rows to insert. Each is an object of column → value (camelCase or snake_case column names).'),
-});
-const AddRecordsSchema = toolSchema(AddRecordsZod);
-export const addRecordsTool = {
-    name: 'add_records',
-    label: 'Add records',
-    description: "Insert one or more rows into a table in the project's app database.",
-    promptSnippet: 'add_records: insert rows into an existing table. Gated.',
-    parameters: AddRecordsSchema,
-    async execute(_id, params, _signal, _onUpdate, ctx) {
-        const resolved = await resolveProjectContext(ctx.cwd);
-        if (!resolved.context)
-            return fail(resolved.reason);
-        const { dataEndpoint } = resolved.context;
-        if (!dataEndpoint) {
-            return fail('Cannot resolve the app data endpoint (DATABASE_NAME missing from .env). Re-provision the database, then retry.');
-        }
-        if (params.records.length === 0)
-            return fail('No records provided.');
-        const token = await resolveDataToken(resolved.context);
-        if (!token.token)
-            return needsAuth(token.reason ?? 'Sign in to the database to insert records.');
-        const adapter = new objects.FetchAdapter(dataEndpoint, {
-            Authorization: `Bearer ${token.token}`,
-        });
-        let tables;
-        try {
-            const meta = await adapter.execute(META_QUERY);
-            if (!meta.ok) {
-                return fail(`Failed to read schema from the app database: ${meta.errors.map((e) => e.message).join('; ')}`);
-            }
-            tables = (meta.data._meta?.tables ?? []).filter((t) => Boolean(t));
-        }
-        catch (err) {
-            return fail(err instanceof Error ? err.message : 'Failed to query the app database schema.');
-        }
-        const rawTable = findMetaTable(tables, params.table_name);
-        if (!rawTable) {
-            return fail(`Table "${params.table_name}" was not found in the app database.`);
-        }
-        const table = cleanTable(rawTable);
-        const allTables = tables.map(cleanTable);
-        const mutation = buildPostGraphileCreate(table, allTables).toString();
-        const mutationName = toCreateMutationName(table.name, table);
-        const singularName = toCamelCaseSingular(table.name, table);
-        // Constructive app tables scope rows by entityId (the owning user's id). The
-        // create input requires it, but callers won't know it — backfill it with the
-        // signed-in user's id from the Preview session when the table has the column
-        // and the record omits it.
-        const hasEntityId = table.fields.some((f) => f.name === 'entityId');
-        const created = [];
-        const errors = [];
-        for (const record of params.records) {
-            const prepared = hasEntityId && token.userId && record.entityId == null && record.entity_id == null
-                ? { ...record, entityId: token.userId }
-                : record;
-            const variables = { input: { [singularName]: stripForCreate(prepared) } };
-            try {
-                const result = await adapter.execute(mutation, variables);
-                if (!result.ok) {
-                    errors.push(result.errors.map((e) => e.message).join('; '));
-                    continue;
-                }
-                const payload = result.data[mutationName];
-                const row = payload?.[singularName] ?? {};
-                created.push(row);
-            }
-            catch (err) {
-                errors.push(err instanceof Error ? err.message : 'Unknown error');
-            }
-        }
-        if (created.length === 0) {
-            return fail(`Failed to insert into "${params.table_name}": ${errors.join('; ') || 'unknown error'}`);
-        }
-        const columns = table.fields.map((f) => f.name);
-        const message = errors.length > 0
-            ? `Inserted ${created.length} of ${params.records.length} row(s) into ${params.table_name} (${errors.length} failed).`
-            : `Inserted ${created.length} row(s) into ${params.table_name}.`;
-        return {
-            content: [{ type: 'text', text: message }],
-            details: {
-                success: true,
-                message,
-                tableName: rawTable.name,
-                columns,
-                rows: created,
-                createdCount: created.length,
-                asOf: new Date().toISOString(),
-            },
-        };
-    },
-};