@agentic-kit/pi 0.17.0 → 0.18.0

package/provision-database/resolve.d.ts

@@ -1,27 +0,0 @@
-import { type ProvisionModule } from './presets';
-export interface ProvisionOverlay {
-    /**
-     * Base preset name to resolve from (e.g. 'b2b:storage', 'full'). The last
-     * layer that sets `preset` wins; if none set it, `DEFAULT_PROVISION_PRESET`
-     * is used.
-     */
-    preset?: string;
-    /**
-     * Modules to add. An entry whose key matches an existing module OVERRIDES it
-     * (e.g. re-declaring `storage_module` with app-specific options); a new key
-     * is appended.
-     */
-    add?: ProvisionModule[];
-    /**
-     * Module names or `name:scope` keys to drop from the base. A bare name
-     * removes every scope of that module; `name:scope` removes just that one.
-     */
-    remove?: string[];
-}
-/** Stable identity for a module entry: `name` or `name:scope` when scoped. */
-export declare function moduleKey(m: ProvisionModule): string;
-/**
- * Resolve the effective module list from a pinned preset plus ordered overlays.
- * Pure: no I/O, no host access. Later overlays win (last-write-wins by key).
- */
-export declare function resolveProvisionModules(layers?: ProvisionOverlay[]): ProvisionModule[];

package/provision-database/resolve.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.moduleKey = moduleKey;
-exports.resolveProvisionModules = resolveProvisionModules;
-// Ordered-overlay resolution for provision modules.
-//
-// Mirrors the skills overlay model (`@agentic-kit/harness` skills manifest): a
-// pinned base (a named preset from `node-type-registry`) is layered under zero
-// or more overlays, later layers winning by module key. An empty overlay list
-// resolves to the base preset unchanged.
-const presets_1 = require("./presets");
-function moduleName(m) {
-    return Array.isArray(m) ? m[0] : m;
-}
-function moduleScope(m) {
-    if (!Array.isArray(m))
-        return undefined;
-    const scope = m[1]?.scope;
-    return typeof scope === 'string' ? scope : undefined;
-}
-/** Stable identity for a module entry: `name` or `name:scope` when scoped. */
-function moduleKey(m) {
-    const scope = moduleScope(m);
-    return scope ? `${moduleName(m)}:${scope}` : moduleName(m);
-}
-/**
- * Resolve the effective module list from a pinned preset plus ordered overlays.
- * Pure: no I/O, no host access. Later overlays win (last-write-wins by key).
- */
-function resolveProvisionModules(layers = []) {
-    const presetName = [...layers].reverse().find((l) => l.preset)?.preset ?? presets_1.DEFAULT_PROVISION_PRESET;
-    const preset = (0, presets_1.getModulePreset)(presetName);
-    if (!preset) {
-        const known = presets_1.allModulePresets.map((p) => p.name).join(', ');
-        throw new Error(`Unknown provision preset "${presetName}". Known presets: ${known}.`);
-    }
-    // Ordered map keyed by module identity preserves position while allowing
-    // overrides (same key) and appends (new key).
-    const resolved = new Map();
-    for (const m of preset.modules)
-        resolved.set(moduleKey(m), m);
-    for (const layer of layers) {
-        for (const target of layer.remove ?? []) {
-            for (const key of [...resolved.keys()]) {
-                if (key === target || key.split(':')[0] === target)
-                    resolved.delete(key);
-            }
-        }
-        for (const m of layer.add ?? [])
-            resolved.set(moduleKey(m), m);
-    }
-    return [...resolved.values()];
-}

package/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/records/meta.js

@@ -1,172 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.META_QUERY = void 0;
-exports.cleanTable = cleanTable;
-exports.findMetaTable = findMetaTable;
-// 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.
-exports.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,
-    };
-}
-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.
-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/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/run-codegen/barrels.js

@@ -1,54 +0,0 @@
-"use strict";
-// 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.
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeSdkBarrels = normalizeSdkBarrels;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("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. */
-function normalizeSdkBarrels(root) {
-    if (!node_fs_1.default.existsSync(root))
-        return 0;
-    let changed = 0;
-    const walk = (dir) => {
-        for (const entry of node_fs_1.default.readdirSync(dir, { withFileTypes: true })) {
-            const p = node_path_1.default.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                walk(p);
-                continue;
-            }
-            if (!/\.tsx?$/.test(entry.name))
-                continue;
-            const orig = node_fs_1.default.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 = node_path_1.default.resolve(node_path_1.default.dirname(p), spec);
-                if (node_fs_1.default.existsSync(abs) && node_fs_1.default.statSync(abs).isDirectory()) {
-                    return pre + spec.replace(/\/$/, '') + '/index' + post;
-                }
-                return match;
-            });
-            if (next !== orig) {
-                node_fs_1.default.writeFileSync(p, next);
-                changed++;
-            }
-        }
-    };
-    walk(root);
-    return changed;
-}

package/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/run-codegen/endpoints.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.derivePlaneEndpoints = derivePlaneEndpoints;
-exports.codegenEndpointEnv = codegenEndpointEnv;
-exports.envLocalContent = envLocalContent;
-// 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).
-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.
-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.
-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/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/schema-resolve.js

@@ -1,75 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveSchema = resolveSchema;
-exports.resolveTable = resolveTable;
-exports.resolveField = resolveField;
-exports.findUniqueConstraintId = findUniqueConstraintId;
-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 };
-}
-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;
-}
-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;
-}
-function findUniqueConstraintId(table, fieldId) {
-    return table.uniqueConstraints.find((c) => c.fieldIds.includes(fieldId))?.id;
-}

package/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/tool-schema.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toolSchema = toolSchema;
-const zod_1 = require("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.
-function toolSchema(schema) {
-    const { $schema: _$schema, ...rest } = zod_1.z.toJSONSchema(schema, { target: 'draft-7' });
-    return rest;
-}

package/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/tools/add-policies.js

@@ -1,99 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addPoliciesTool = void 0;
-const harness_1 = require("@agentic-kit/harness");
-const zod_1 = require("zod");
-const context_1 = require("../context");
-const add_policies_to_table_1 = require("../policy/add-policies-to-table");
-const schema_resolve_1 = require("../schema-resolve");
-const tool_schema_1 = require("../tool-schema");
-const DEFAULT_ROLE = 'authenticated';
-const CrudOperationSchema = zod_1.z.enum(['create', 'read', 'update', 'delete']);
-const PolicyEntrySchema = zod_1.z.object({
-    policy_type: zod_1.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: zod_1.z
-        .array(CrudOperationSchema)
-        .min(1)
-        .describe('CRUD operations the policy applies to: any subset of ["create","read","update","delete"].'),
-    role_name: zod_1.z
-        .string()
-        .describe('PostgreSQL role the policy applies to. Defaults to "authenticated".')
-        .optional(),
-    is_permissive: zod_1.z
-        .boolean()
-        .describe('PERMISSIVE (default true) vs RESTRICTIVE — most policies should be permissive.')
-        .optional(),
-    data: zod_1.z
-        .record(zod_1.z.string(), zod_1.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: zod_1.z
-        .record(zod_1.z.string(), zod_1.z.unknown())
-        .describe('Optional data for the underlying Data* node (has-module policies only).')
-        .optional(),
-});
-const AddPoliciesZod = zod_1.z.object({
-    table_name: zod_1.z
-        .string()
-        .describe('Name of the existing table to attach the policies to. Use describe_schema first to verify it exists.'),
-    policies: zod_1.z
-        .array(PolicyEntrySchema)
-        .min(1)
-        .describe('One or more policies to add. Each entry becomes one secure_table_provision call.'),
-});
-const AddPoliciesSchema = (0, tool_schema_1.toolSchema)(AddPoliciesZod);
-function buildOperations(roleName, isPermissive) {
-    const config = { roleName, isPermissive, policyData: {}, isCustomized: false };
-    return { create: config, read: config, update: config, delete: config };
-}
-exports.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 (0, context_1.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 (0, schema_resolve_1.resolveSchema)(resolved.context);
-            const table = (0, schema_resolve_1.resolveTable)(schema, params.table_name);
-            const policies = params.policies.map((entry) => {
-                const config = (0, harness_1.getPolicyProvisioningConfig)(entry.policy_type);
-                const defaults = (0, harness_1.getPolicyFieldDefaults)(entry.policy_type);
-                const mergedData = { ...defaults, ...(entry.data ?? {}) };
-                const nodeData = entry.node_data ?? (0, harness_1.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 (0, add_policies_to_table_1.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/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 {};