botinabox 2.4.2 → 2.5.0

package/dist/core/data/data-store.js

@@ -1,218 +0,0 @@
-import { Lattice } from 'latticesql';
-export class DataStoreError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'DataStoreError';
-    }
-}
-/**
- * Thin wrapper around Lattice that provides the botinabox DataStore API.
- *
- * Delegates all data operations to the latticesql package. Application-level
- * events (task.created, run.completed, etc.) remain on the HookBus — they are
- * emitted by orchestrator modules, not the data layer.
- */
-export class DataStore {
-    lattice;
-    hooks;
-    outputDir;
-    _initialized = false;
-    deferredStatements = [];
-    constructor(opts) {
-        this.lattice = new Lattice(opts.dbPath, {
-            wal: opts.wal ?? true,
-        });
-        this.outputDir = opts.outputDir;
-        this.hooks = opts.hooks;
-    }
-    /**
-     * Register a table definition. Must be called before init().
-     *
-     * tableConstraints may contain both inline constraints (FOREIGN KEY, UNIQUE)
-     * and standalone SQL statements (CREATE INDEX). Standalone statements are
-     * deferred and executed after init() creates the tables.
-     */
-    define(name, def) {
-        if (this._initialized) {
-            throw new DataStoreError('Cannot define tables after init()');
-        }
-        const inlineConstraints = [];
-        for (const stmt of def.tableConstraints ?? []) {
-            const upper = stmt.trimStart().toUpperCase();
-            if (upper.startsWith('CREATE ') || upper.startsWith('DROP ') || upper.startsWith('ALTER ')) {
-                // Prevent multi-statement injection via semicolons
-                if (stmt.includes(';')) {
-                    throw new DataStoreError(`Deferred DDL statement must not contain semicolons: ${stmt}`);
-                }
-                this.deferredStatements.push(stmt);
-            }
-            else {
-                inlineConstraints.push(stmt);
-            }
-        }
-        this.lattice.define(name, {
-            columns: def.columns,
-            primaryKey: def.primaryKey,
-            tableConstraints: inlineConstraints.length ? inlineConstraints : undefined,
-            relations: def.relations,
-            filter: def.filter,
-            render: def.render,
-            outputFile: def.outputFile,
-        });
-    }
-    /**
-     * Register an entity context definition for per-entity file rendering.
-     */
-    defineEntityContext(name, def) {
-        this.lattice.defineEntityContext(name, {
-            slug: (row) => {
-                const val = row[def.slugColumn];
-                const raw = val == null ? String(row.id ?? row.name ?? 'unknown') : String(val);
-                // Validate: no path traversal characters
-                if (raw.includes('/') || raw.includes('\\') || raw.includes('..')) {
-                    throw new Error(`Invalid slug "${raw}": contains path traversal characters`);
-                }
-                return raw;
-            },
-            directoryRoot: def.directory,
-            files: def.files,
-            protectedFiles: def.protectedFiles,
-            protected: def.protected,
-            encrypted: def.encrypted,
-            // Note: sourceDefaults.softDelete NOT set here because junction tables
-            // (agent_project, rule_agent, etc.) don't have deleted_at columns.
-            // Entity context render functions should add softDelete per-source when targeting
-            // tables that support it.
-            index: def.indexFile
-                ? {
-                    outputFile: def.indexFile,
-                    render: def.indexRender ?? ((rows) => {
-                        const active = rows.filter((r) => r.deleted_at == null);
-                        const dir = def.directory;
-                        const title = dir.charAt(0).toUpperCase() + dir.slice(1);
-                        if (!active.length)
-                            return `# ${title}\n\nNone.\n`;
-                        const lines = active.map((r) => {
-                            const slug = String(r[def.slugColumn] ?? r.name ?? r.id ?? 'unknown');
-                            const name = String(r.name ?? slug);
-                            const status = r.status ? ` (${r.status})` : '';
-                            return `- [${name}](${dir}/${slug}/)${status}`;
-                        });
-                        return `# ${title}\n\n${lines.join('\n')}\n`;
-                    }),
-                }
-                : undefined,
-        });
-    }
-    async init(opts) {
-        await this.lattice.init({ migrations: opts?.migrations });
-        // Run deferred statements (CREATE INDEX, etc.) after tables exist
-        for (const stmt of this.deferredStatements) {
-            this.lattice.db.exec(stmt);
-        }
-        this._initialized = true;
-    }
-    assertInitialized() {
-        if (!this._initialized) {
-            throw new DataStoreError('DataStore not initialized — call init() first');
-        }
-    }
-    // --- CRUD -----------------------------------------------------------
-    async insert(table, row) {
-        this.assertInitialized();
-        return this.lattice.insertReturning(table, row);
-    }
-    async upsert(table, row) {
-        this.assertInitialized();
-        const id = await this.lattice.upsert(table, row);
-        const result = await this.lattice.get(table, id);
-        return result ?? { ...row, id };
-    }
-    async update(table, pk, changes) {
-        this.assertInitialized();
-        return this.lattice.updateReturning(table, pk, changes);
-    }
-    async delete(table, pk) {
-        this.assertInitialized();
-        await this.lattice.delete(table, pk);
-    }
-    /**
-     * Get a single row by primary key.
-     * Returns undefined if not found (Lattice returns null).
-     */
-    async get(table, pk) {
-        this.assertInitialized();
-        const result = await this.lattice.get(table, pk);
-        return result ?? undefined;
-    }
-    async query(table, opts) {
-        this.assertInitialized();
-        return this.lattice.query(table, opts);
-    }
-    async count(table, opts) {
-        this.assertInitialized();
-        return this.lattice.count(table, opts);
-    }
-    // --- Junctions ------------------------------------------------------
-    async link(junctionTable, row) {
-        this.assertInitialized();
-        await this.lattice.link(junctionTable, row);
-    }
-    async unlink(junctionTable, row) {
-        this.assertInitialized();
-        await this.lattice.unlink(junctionTable, row);
-    }
-    // --- Migrations -----------------------------------------------------
-    async migrate(migrations) {
-        this.assertInitialized();
-        await this.lattice.migrate(migrations);
-    }
-    // --- Seed -----------------------------------------------------------
-    async seed(items) {
-        this.assertInitialized();
-        for (const item of items) {
-            const naturalKey = Array.isArray(item.naturalKey)
-                ? item.naturalKey[0]
-                : (item.naturalKey ?? 'id');
-            await this.lattice.seed({
-                table: item.table,
-                data: item.rows,
-                naturalKey,
-                softDeleteMissing: item.softDeleteMissing,
-            });
-            if (item.junctions) {
-                for (const junc of item.junctions) {
-                    for (const linkRow of junc.items) {
-                        await this.lattice.link(junc.table, linkRow);
-                    }
-                }
-            }
-        }
-    }
-    // --- Rendering ------------------------------------------------------
-    async render() {
-        this.assertInitialized();
-        if (this.outputDir) {
-            await this.lattice.render(this.outputDir);
-        }
-    }
-    async reconcile() {
-        this.assertInitialized();
-        if (this.outputDir) {
-            await this.lattice.reconcile(this.outputDir);
-        }
-    }
-    // --- Schema introspection ------------------------------------------
-    tableInfo(table) {
-        this.assertInitialized();
-        return this.lattice.db.pragma(`table_info(${table})`);
-    }
-    // --- Lifecycle ------------------------------------------------------
-    close() {
-        this.lattice.close();
-        this._initialized = false;
-    }
-    on(event, handler) {
-        this.hooks?.register(event, handler);
-    }
-}

package/dist/core/data/domain-entity-contexts.d.ts

@@ -1,29 +0,0 @@
-import type { DataStore } from "./data-store.js";
-/**
- * Options for domain entity context generation.
- * Match the options used in defineDomainTables().
- */
-export interface DomainEntityContextOptions {
-    clients?: boolean;
-    repositories?: boolean;
-    files?: boolean;
-    channels?: boolean;
-    rules?: boolean;
-}
-/**
- * Define entity context rendering for standard domain tables.
- * Call after defineDomainTables() and defineCoreTables().
- *
- * Renders per-entity directories with context files for:
- * org, project, + optional client, file, channel entities.
- * Also adds PROJECTS.md, RULES.md, SKILLS.md, REPOS.md to agent context.
- *
- * @example
- * ```ts
- * defineCoreTables(db);
- * defineDomainTables(db);
- * defineCoreEntityContexts(db);    // agents, users, skills
- * defineDomainEntityContexts(db);  // org, project, client, file, channel
- * ```
- */
-export declare function defineDomainEntityContexts(db: DataStore, options?: DomainEntityContextOptions): void;

package/dist/core/data/domain-entity-contexts.js

@@ -1,321 +0,0 @@
-import { truncateAtWord } from "../../shared/utils.js";
-/**
- * Define entity context rendering for standard domain tables.
- * Call after defineDomainTables() and defineCoreTables().
- *
- * Renders per-entity directories with context files for:
- * org, project, + optional client, file, channel entities.
- * Also adds PROJECTS.md, RULES.md, SKILLS.md, REPOS.md to agent context.
- *
- * @example
- * ```ts
- * defineCoreTables(db);
- * defineDomainTables(db);
- * defineCoreEntityContexts(db);    // agents, users, skills
- * defineDomainEntityContexts(db);  // org, project, client, file, channel
- * ```
- */
-export function defineDomainEntityContexts(db, options = {}) {
-    const opts = {
-        clients: true,
-        repositories: true,
-        files: true,
-        channels: true,
-        rules: true,
-        ...options,
-    };
-    // --- Extend agent context with project/rule/skill connections ---
-    // NOTE: This must be called BEFORE defineCoreEntityContexts() or the agent
-    // context will already be registered. Apps should call this first, then core.
-    // Actually, botinabox registers agents in defineCoreEntityContexts() already.
-    // So we skip re-defining agents here — apps add PROJECTS.md etc. themselves.
-    // --- Org context ---
-    db.defineEntityContext("org", {
-        table: "org",
-        directory: "orgs",
-        slugColumn: "id",
-        indexFile: "orgs/ORGS.md",
-        files: {
-            "ORG.md": {
-                source: { type: "self" },
-                render: (rows) => {
-                    const o = rows[0];
-                    if (!o)
-                        return "";
-                    return [
-                        `# ${o.name}`,
-                        "",
-                        o.type ? `**Type:** ${o.type}` : null,
-                        o.description ? `\n${o.description}` : null,
-                        o.mission ? `\n**Mission:** ${o.mission}` : null,
-                        o.website ? `**Website:** ${o.website}` : null,
-                        "",
-                    ]
-                        .filter(Boolean)
-                        .join("\n");
-                },
-            },
-        },
-    });
-    // --- Project context ---
-    // PROJECT.md auto-combines with all connected context (latticesql 1.2.0+).
-    db.defineEntityContext("project", {
-        table: "project",
-        directory: "projects",
-        slugColumn: "id",
-        indexFile: "projects/PROJECTS.md",
-        files: {
-            "PROJECT.md": {
-                source: { type: "self" },
-                render: (rows) => {
-                    const p = rows[0];
-                    if (!p)
-                        return "";
-                    return [
-                        `# ${p.name}`,
-                        "",
-                        p.status ? `**Status:** ${p.status}` : null,
-                        p.description ? `\n${p.description}` : null,
-                        p.tech_stack ? `\n**Tech Stack:** ${p.tech_stack}` : null,
-                        p.production_url ? `**URL:** ${p.production_url}` : null,
-                        p.github_repo ? `**GitHub:** ${p.github_repo}` : null,
-                        p.deploy_target ? `**Deploy:** ${p.deploy_target}` : null,
-                        p.branch_strategy
-                            ? `**Branch Strategy:** ${p.branch_strategy}`
-                            : null,
-                        p.notes ? `\n**Notes:**\n${p.notes}` : null,
-                        "",
-                    ]
-                        .filter(Boolean)
-                        .join("\n");
-                },
-            },
-            ...(opts.repositories
-                ? {
-                    "REPOS.md": {
-                        source: {
-                            type: "hasMany",
-                            table: "repository",
-                            foreignKey: "project_id",
-                        },
-                        render: (rows) => {
-                            if (!rows.length)
-                                return "";
-                            const lines = rows.map((r) => `- **${r.name}** — ${r.url ?? ""}`);
-                            return `# Repositories\n\n${lines.join("\n")}\n`;
-                        },
-                        omitIfEmpty: true,
-                    },
-                }
-                : {}),
-            ...(opts.rules
-                ? {
-                    "RULES.md": {
-                        source: {
-                            type: "manyToMany",
-                            junctionTable: "rule_project",
-                            localKey: "project_id",
-                            remoteKey: "rule_id",
-                            remoteTable: "rule",
-                            softDelete: true,
-                            orderBy: "priority",
-                        },
-                        render: (rows) => {
-                            if (!rows.length)
-                                return "";
-                            const lines = rows.map((r) => `### ${r.title}\n${r.rule_text}`);
-                            return `# Project Rules\n\n${lines.join("\n\n")}\n`;
-                        },
-                        omitIfEmpty: true,
-                    },
-                }
-                : {}),
-            ...(opts.files
-                ? {
-                    "FILES.md": {
-                        source: {
-                            type: "hasMany",
-                            table: "file",
-                            foreignKey: "project_id",
-                        },
-                        render: (rows) => {
-                            if (!rows.length)
-                                return "";
-                            const lines = rows.map((r) => `- [${r.name}](files/${r.name}/)${r.mime_type ? ` (${r.mime_type})` : ""}`);
-                            return `# Files\n\n${lines.join("\n")}\n`;
-                        },
-                        omitIfEmpty: true,
-                    },
-                }
-                : {}),
-            "MESSAGES.md": {
-                source: {
-                    type: "hasMany",
-                    table: "messages",
-                    foreignKey: "project_id",
-                    orderBy: "created_at",
-                    limit: 100,
-                },
-                render: (rows) => {
-                    if (!rows.length)
-                        return "# Messages\n\nNo messages.\n";
-                    const lines = rows.map((r) => {
-                        const dir = r.direction === "inbound" ? "\u2192" : "\u2190";
-                        const ts = (r.created_at ?? "").slice(0, 16);
-                        const agent = r.from_agent ? ` [${r.from_agent}]` : "";
-                        const body = r.body ?? "";
-                        const preview = truncateAtWord(body, 150);
-                        const link = `[${ts}](messages/${r.id}/)`;
-                        return `- ${dir} **${link}**${agent} ${preview}`;
-                    });
-                    return `# Messages\n\n${lines.join("\n")}\n`;
-                },
-                omitIfEmpty: false,
-            },
-        },
-    });
-    // --- Client context ---
-    // CLIENT.md auto-combines with all connected context (latticesql 1.2.0+).
-    if (opts.clients) {
-        db.defineEntityContext("client", {
-            table: "client",
-            directory: "clients",
-            slugColumn: "id",
-            indexFile: "clients/CLIENTS.md",
-            files: {
-                "CLIENT.md": {
-                    source: { type: "self" },
-                    render: (rows) => {
-                        const c = rows[0];
-                        if (!c)
-                            return "";
-                        return [
-                            `# ${c.name}`,
-                            "",
-                            c.contact_name ? `**Contact:** ${c.contact_name}` : null,
-                            c.contact_email ? `**Email:** ${c.contact_email}` : null,
-                            c.phone ? `**Phone:** ${c.phone}` : null,
-                            c.status ? `**Status:** ${c.status}` : null,
-                            c.notes ? `\n${c.notes}` : null,
-                            "",
-                        ]
-                            .filter(Boolean)
-                            .join("\n");
-                    },
-                },
-                ...(opts.repositories
-                    ? {
-                        "REPOS.md": {
-                            source: {
-                                type: "hasMany",
-                                table: "repository",
-                                foreignKey: "client_id",
-                            },
-                            render: (rows) => {
-                                if (!rows.length)
-                                    return "";
-                                const lines = rows.map((r) => `- **${r.name}** — ${r.url ?? ""}`);
-                                return `# Repositories\n\n${lines.join("\n")}\n`;
-                            },
-                            omitIfEmpty: true,
-                        },
-                    }
-                    : {}),
-                AGENTS: {
-                    source: {
-                        type: "manyToMany",
-                        junctionTable: "agent_client",
-                        localKey: "client_id",
-                        remoteKey: "agent_id",
-                        remoteTable: "agents",
-                    },
-                    render: (rows) => {
-                        if (!rows.length)
-                            return "";
-                        const lines = rows.map((r) => `- **${r.name}** (${r.role ?? "agent"})`);
-                        return `# Assigned Agents\n\n${lines.join("\n")}\n`;
-                    },
-                    omitIfEmpty: true,
-                },
-                "INVOICES.md": {
-                    source: {
-                        type: "hasMany",
-                        table: "invoice",
-                        foreignKey: "client_id",
-                    },
-                    render: (rows) => {
-                        if (!rows.length)
-                            return "";
-                        const lines = rows.map((r) => {
-                            const amt = r.amount_cents
-                                ? `$${(r.amount_cents / 100).toFixed(2)}`
-                                : "TBD";
-                            return `- **${r.number ?? "Draft"}** — ${amt} (${r.status})${r.description ? ": " + r.description : ""}`;
-                        });
-                        return `# Invoices\n\n${lines.join("\n")}\n`;
-                    },
-                    omitIfEmpty: true,
-                },
-            },
-        });
-    }
-    // --- File context ---
-    if (opts.files) {
-        db.defineEntityContext("file", {
-            table: "file",
-            directory: "files",
-            slugColumn: "id",
-            indexFile: "files/FILES.md",
-            files: {
-                "FILE.md": {
-                    source: { type: "self" },
-                    render: (rows) => {
-                        const f = rows[0];
-                        if (!f)
-                            return "";
-                        return [
-                            `# ${f.name}`,
-                            "",
-                            f.mime_type ? `**Type:** ${f.mime_type}` : null,
-                            f.access_level ? `**Access:** ${f.access_level}` : null,
-                            f.file_path ? `**Path:** ${f.file_path}` : null,
-                            f.description ? `\n${f.description}` : null,
-                            "",
-                        ]
-                            .filter(Boolean)
-                            .join("\n");
-                    },
-                },
-            },
-        });
-    }
-    // --- Channel context ---
-    if (opts.channels) {
-        db.defineEntityContext("channel", {
-            table: "channel",
-            directory: "channels",
-            slugColumn: "id",
-            indexFile: "channels/CHANNELS.md",
-            files: {
-                "CHANNEL.md": {
-                    source: { type: "self" },
-                    render: (rows) => {
-                        const c = rows[0];
-                        if (!c)
-                            return "";
-                        return [
-                            `# ${c.name}`,
-                            "",
-                            c.platform ? `**Platform:** ${c.platform}` : null,
-                            c.type ? `**Type:** ${c.type}` : null,
-                            c.instructions ? `\n${c.instructions}` : null,
-                            "",
-                        ]
-                            .filter(Boolean)
-                            .join("\n");
-                    },
-                },
-            },
-        });
-    }
-}

package/dist/core/data/domain-schema.d.ts

@@ -1,36 +0,0 @@
-import type { DataStore } from "./data-store.js";
-/**
- * Options for domain table generation.
- * Enable/disable optional tables based on your app's needs.
- */
-export interface DomainSchemaOptions {
-    /** Include client + invoice tables (default: true) */
-    clients?: boolean;
-    /** Include repository table (default: true) */
-    repositories?: boolean;
-    /** Include file table (default: true) */
-    files?: boolean;
-    /** Include channel table (default: true) */
-    channels?: boolean;
-    /** Include rule table + junction tables (default: true) */
-    rules?: boolean;
-    /** Include event audit log (default: true) */
-    events?: boolean;
-    /** Include cross-domain junction tables (default: true) */
-    junctions?: boolean;
-}
-/**
- * Define standard domain tables that most multi-agent apps need.
- * Call after defineCoreTables() and before db.init().
- *
- * Provides: org, project, + optional client, invoice, repository,
- * file, channel, rule, event tables with appropriate junction tables.
- *
- * @example
- * ```ts
- * defineCoreTables(db);
- * defineDomainTables(db);          // all tables
- * defineDomainTables(db, { clients: false }); // skip client/invoice
- * ```
- */
-export declare function defineDomainTables(db: DataStore, options?: DomainSchemaOptions): void;