dbctx 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+export type TSSLMode = "disable" | "allow" | "prefer" | "require" | "verify-ca" | "verify-full";
+export interface ConnectionOptions {
+    hostname?: string;
+    port?: number;
+    database?: string;
+    username?: string;
+    sslmode?: TSSLMode;
+    sslcert?: string;
+    sslkey?: string;
+    sslrootcert?: string;
+    sshHost?: string;
+    sshPort?: number;
+    sshUsername?: string;
+    sshPrivateKey?: string;
+}
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"./src/","sources":["index.mts"],"names":[],"mappings":";AAOA,MAAM,MAAM,QAAQ,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,aAAa,CAAC;AAEhG,MAAM,WAAW,iBAAiB;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,QAAQ,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B"}

package/dist/index.mjs

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { render } from "ink";
+import { Error } from "./components/Error.js";
+import { App } from "./App.js";
+import { validatePathOptions } from "./validatePaths.mjs";
+const program = new Command();
+program
+    .name("dbctx")
+    .description("AI generated docs from your application database")
+    .version("1.0.0")
+    .argument("[connection-string]", "PostgreSQL connection string (env: DATABASE_URL)")
+    .option("-h, --hostname <host>", "database hostname (env: PGHOST, default: localhost)")
+    .option("-p, --port <port>", "database port (env: PGPORT, default: 5432)", parseInt)
+    .option("-d, --database <name>", "database name (env: PGDATABASE, default: postgres)")
+    .option("-U, --username <user>", "database username (env: PGUSER, default: postgres)")
+    .option("--sslmode <mode>", "SSL mode: disable|allow|prefer|require|verify-ca|verify-full (env: PGSSLMODE, default: prefer)")
+    .option("--sslcert <path>", "path to client certificate (env: PGSSLCERT)")
+    .option("--sslkey <path>", "path to client private key (env: PGSSLKEY)")
+    .option("--sslrootcert <path>", "path to root CA certificate (env: PGSSLROOTCERT)")
+    .option("--ssh-host <host>", "SSH tunnel host (bastion/jump server)")
+    .option("--ssh-port <port>", "SSH tunnel port (default: 22)", parseInt)
+    .option("--ssh-username <user>", "SSH tunnel username (default: $USER)")
+    .option("--ssh-private-key <path>", "path to SSH private key (default: ~/.ssh/id_rsa)")
+    .action((connectionString, options) => {
+    const hasConnectionString = Boolean(connectionString);
+    const hasIndividualOptions = Boolean(options.hostname || options.port || options.database || options.username);
+    if (hasConnectionString && hasIndividualOptions) {
+        render(Error({
+            message: "Cannot use both connection string and individual options (-h, -p, -d, -U). Use one or the other.",
+        }));
+        process.exit(1);
+    }
+    // Validate path options exist on filesystem
+    const { errors: pathErrors, expandedPaths } = validatePathOptions(options);
+    if (pathErrors.length > 0) {
+        const errorMessages = pathErrors
+            .map(({ option, path }) => `  ${option}: ${path}`)
+            .join("\n");
+        render(Error({
+            message: `The following paths do not exist:\n${errorMessages}`,
+        }));
+        process.exit(1);
+    }
+    // Replace original paths with expanded paths (~ resolved to home directory)
+    const validatedOptions = {
+        ...options,
+        ...expandedPaths,
+    };
+    if (hasIndividualOptions) {
+        const requiredOptions = [
+            { key: "hostname", flag: "-h/--hostname" },
+            { key: "port", flag: "-p/--port" },
+            { key: "database", flag: "-d/--database" },
+            { key: "username", flag: "-U/--username" },
+        ];
+        const missing = requiredOptions
+            .filter(({ key }) => !validatedOptions[key])
+            .map(({ flag }) => flag);
+        if (missing.length > 0) {
+            render(Error({
+                message: `Missing required options: ${missing.join(", ")}`,
+            }));
+            process.exit(1);
+        }
+    }
+    // All validations passed - build config and render the app
+    const config = {
+        connectionString,
+        ...validatedOptions,
+    };
+    render(App({ config }));
+});
+program.parse();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.mjs","sourceRoot":"./src/","sources":["index.mts"],"names":[],"mappings":"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","sourcesContent":["#!/usr/bin/env node\nimport { Command } from \"commander\";\nimport { render } from \"ink\";\nimport { Error } from \"./components/Error.js\";\nimport { App, type TConnectionConfig } from \"./App.js\";\nimport { validatePathOptions, type TPathValidationError } from \"./validatePaths.mjs\";\n\nexport type TSSLMode = \"disable\" | \"allow\" | \"prefer\" | \"require\" | \"verify-ca\" | \"verify-full\";\n\nexport interface ConnectionOptions {\n    hostname?: string;\n    port?: number;\n    database?: string;\n    username?: string;\n    sslmode?: TSSLMode;\n    sslcert?: string;\n    sslkey?: string;\n    sslrootcert?: string;\n    sshHost?: string;\n    sshPort?: number;\n    sshUsername?: string;\n    sshPrivateKey?: string;\n}\n\nconst program = new Command();\n\nprogram\n    .name(\"dbctx\")\n    .description(\"AI generated docs from your application database\")\n    .version(\"1.0.0\")\n    .argument(\"[connection-string]\", \"PostgreSQL connection string (env: DATABASE_URL)\")\n    .option(\"-h, --hostname <host>\", \"database hostname (env: PGHOST, default: localhost)\")\n    .option(\"-p, --port <port>\", \"database port (env: PGPORT, default: 5432)\", parseInt)\n    .option(\"-d, --database <name>\", \"database name (env: PGDATABASE, default: postgres)\")\n    .option(\"-U, --username <user>\", \"database username (env: PGUSER, default: postgres)\")\n    .option(\"--sslmode <mode>\", \"SSL mode: disable|allow|prefer|require|verify-ca|verify-full (env: PGSSLMODE, default: prefer)\")\n    .option(\"--sslcert <path>\", \"path to client certificate (env: PGSSLCERT)\")\n    .option(\"--sslkey <path>\", \"path to client private key (env: PGSSLKEY)\")\n    .option(\"--sslrootcert <path>\", \"path to root CA certificate (env: PGSSLROOTCERT)\")\n    .option(\"--ssh-host <host>\", \"SSH tunnel host (bastion/jump server)\")\n    .option(\"--ssh-port <port>\", \"SSH tunnel port (default: 22)\", parseInt)\n    .option(\"--ssh-username <user>\", \"SSH tunnel username (default: $USER)\")\n    .option(\"--ssh-private-key <path>\", \"path to SSH private key (default: ~/.ssh/id_rsa)\")\n    .action((connectionString: string | undefined, options: ConnectionOptions) => {\n        const hasConnectionString = Boolean(connectionString);\n        const hasIndividualOptions = Boolean(\n            options.hostname || options.port || options.database || options.username\n        );\n\n        if (hasConnectionString && hasIndividualOptions) {\n            render(\n                Error({\n                    message:\n                        \"Cannot use both connection string and individual options (-h, -p, -d, -U). Use one or the other.\",\n                })\n            );\n\n            process.exit(1);\n        }\n\n        // Validate path options exist on filesystem\n        const { errors: pathErrors, expandedPaths } = validatePathOptions(options);\n\n        if (pathErrors.length > 0) {\n            const errorMessages = pathErrors\n                .map(({ option, path }: TPathValidationError) => `  ${option}: ${path}`)\n                .join(\"\\n\");\n\n            render(\n                Error({\n                    message: `The following paths do not exist:\\n${errorMessages}`,\n                })\n            );\n\n            process.exit(1);\n        }\n\n        // Replace original paths with expanded paths (~ resolved to home directory)\n        const validatedOptions: ConnectionOptions = {\n            ...options,\n            ...expandedPaths,\n        };\n\n        if (hasIndividualOptions) {\n            const requiredOptions = [\n                { key: \"hostname\", flag: \"-h/--hostname\" },\n                { key: \"port\", flag: \"-p/--port\" },\n                { key: \"database\", flag: \"-d/--database\" },\n                { key: \"username\", flag: \"-U/--username\" },\n            ] as const;\n\n            const missing = requiredOptions\n                .filter(({ key }) => !validatedOptions[key])\n                .map(({ flag }) => flag);\n\n            if (missing.length > 0) {\n                render(\n                    Error({\n                        message: `Missing required options: ${missing.join(\", \")}`,\n                    })\n                );\n\n                process.exit(1);\n            }\n        }\n\n        // All validations passed - build config and render the app\n        const config: TConnectionConfig = {\n            connectionString,\n            ...validatedOptions,\n        };\n\n        render(App({ config }));\n    });\n\nprogram.parse();\n"]}

package/dist/logger.d.mts

@@ -0,0 +1,3 @@
+import winston from 'winston';
+export declare const logger: winston.Logger;
+//# sourceMappingURL=logger.d.mts.map

package/dist/logger.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.mts","sourceRoot":"./src/","sources":["logger.mts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,SAAS,CAAC;AAE9B,eAAO,MAAM,MAAM,gBAOjB,CAAC"}

package/dist/logger.mjs

@@ -0,0 +1,7 @@
+import winston from 'winston';
+export const logger = winston.createLogger({
+    level: process.env.NODE_ENV === 'development' ? 'debug' : 'info',
+    format: winston.format.combine(winston.format.timestamp(), winston.format.json()),
+    transports: [new winston.transports.Console()],
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2VyLm1qcyIsInNvdXJjZVJvb3QiOiIuL3NyYy8iLCJzb3VyY2VzIjpbImxvZ2dlci5tdHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxPQUFPLE1BQU0sU0FBUyxDQUFDO0FBRTlCLE1BQU0sQ0FBQyxNQUFNLE1BQU0sR0FBRyxPQUFPLENBQUMsWUFBWSxDQUFDO0lBQ3ZDLEtBQUssRUFBRSxPQUFPLENBQUMsR0FBRyxDQUFDLFFBQVEsS0FBSyxhQUFhLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsTUFBTTtJQUNoRSxNQUFNLEVBQUUsT0FBTyxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQzFCLE9BQU8sQ0FBQyxNQUFNLENBQUMsU0FBUyxFQUFFLEVBQzFCLE9BQU8sQ0FBQyxNQUFNLENBQUMsSUFBSSxFQUFFLENBQ3hCO0lBQ0QsVUFBVSxFQUFFLENBQUMsSUFBSSxPQUFPLENBQUMsVUFBVSxDQUFDLE9BQU8sRUFBRSxDQUFDO0NBQ2pELENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB3aW5zdG9uIGZyb20gJ3dpbnN0b24nO1xuXG5leHBvcnQgY29uc3QgbG9nZ2VyID0gd2luc3Rvbi5jcmVhdGVMb2dnZXIoe1xuICAgIGxldmVsOiBwcm9jZXNzLmVudi5OT0RFX0VOViA9PT0gJ2RldmVsb3BtZW50JyA/ICdkZWJ1ZycgOiAnaW5mbycsXG4gICAgZm9ybWF0OiB3aW5zdG9uLmZvcm1hdC5jb21iaW5lKFxuICAgICAgICB3aW5zdG9uLmZvcm1hdC50aW1lc3RhbXAoKSxcbiAgICAgICAgd2luc3Rvbi5mb3JtYXQuanNvbigpLFxuICAgICksXG4gICAgdHJhbnNwb3J0czogW25ldyB3aW5zdG9uLnRyYW5zcG9ydHMuQ29uc29sZSgpXSxcbn0pO1xuIl19

package/dist/schemas/index.d.mts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.mts.map

package/dist/schemas/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"./src/","sources":["schemas/index.mts"],"names":[],"mappings":""}

package/dist/schemas/index.mjs

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+const relationAttribute = z
+    .object({
+    name: z.string(),
+    data_type: z.string(),
+    is_nullable: z.boolean(),
+    comment: z.string().nullable(),
+})
+    .and(z.discriminatedUnion('kind', [
+    z.discriminatedUnion('has_default', [
+        z.object({
+            kind: z.literal('regular'),
+            has_default: z.literal(false),
+        }),
+        z.object({
+            kind: z.literal('regular'),
+            has_default: z.literal(true),
+            default_expression: z.string(),
+        }),
+    ]),
+    z.object({
+        kind: z.literal('generated'),
+        generated_storage: z.enum(['stored', 'virtual']),
+        generated_expression: z.string(),
+    }),
+]));
+const indexInfo = z
+    .object({
+    index_name: z.string(),
+    relation_name: z.string(),
+    attributes: z.array(z.string()),
+    definition: z.string(),
+    comment: z.string().nullable(),
+})
+    .and(z.discriminatedUnion('index_kind', [
+    z.object({ index_kind: z.literal('primary') }),
+    z.object({ index_kind: z.literal('unique') }),
+    z.object({
+        index_kind: z.literal('exclusion'),
+        exclusion_operators: z.array(z.string()),
+    }),
+    z.object({ index_kind: z.literal('plain') }),
+]))
+    .and(z.discriminatedUnion('is_partial', [
+    z.object({ is_partial: z.literal(false) }),
+    z.object({
+        is_partial: z.literal(true),
+        partial_predicate: z.string(),
+    }),
+]));
+const reference = z.object({
+    constraint_name: z.string(),
+    attributes: z.array(z.string()),
+    referenced_relation: z.string(),
+    referenced_attributes: z.array(z.string()),
+    on_update: z.enum([
+        'NO ACTION',
+        'RESTRICT',
+        'CASCADE',
+        'SET NULL',
+        'SET DEFAULT',
+    ]),
+    on_delete: z.enum([
+        'NO ACTION',
+        'RESTRICT',
+        'CASCADE',
+        'SET NULL',
+        'SET DEFAULT',
+    ]),
+    comment: z.string().nullable(),
+});
+const relation = z.object({
+    name: z.string(),
+    comment: z.string().nullable(),
+    kind: z.enum(['partitioned_table', 'table', 'view', 'materialized_view']),
+    summary: z.string().optional(),
+    details: z.string().optional(),
+    attributes: z.record(z.string(), relationAttribute),
+    references: z.record(z.string(), reference),
+    indexes: z.record(z.string(), indexInfo),
+});
+const relations = z.record(z.string(), relation);
+const database = z.object({
+    type: z.enum(['postgresql']),
+    name: z.string(),
+    comment: z.string().nullable(),
+    summary: z.string().optional(),
+    details: z.string().optional(),
+    relations: relations,
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.mjs","sourceRoot":"./src/","sources":["schemas/index.mts"],"names":[],"mappings":"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","sourcesContent":["import {z} from 'zod';\n\nconst relationAttribute = z\n    .object({\n        name: z.string(),\n        data_type: z.string(),\n        is_nullable: z.boolean(),\n        comment: z.string().nullable(),\n    })\n    .and(\n        z.discriminatedUnion('kind', [\n            z.discriminatedUnion('has_default', [\n                z.object({\n                    kind: z.literal('regular'),\n                    has_default: z.literal(false),\n                }),\n                z.object({\n                    kind: z.literal('regular'),\n                    has_default: z.literal(true),\n                    default_expression: z.string(),\n                }),\n            ]),\n            z.object({\n                kind: z.literal('generated'),\n                generated_storage: z.enum(['stored', 'virtual']),\n                generated_expression: z.string(),\n            }),\n        ]),\n    );\n\nconst indexInfo = z\n    .object({\n        index_name: z.string(),\n        relation_name: z.string(),\n        attributes: z.array(z.string()),\n        definition: z.string(),\n        comment: z.string().nullable(),\n    })\n    .and(\n        z.discriminatedUnion('index_kind', [\n            z.object({ index_kind: z.literal('primary') }),\n            z.object({ index_kind: z.literal('unique') }),\n            z.object({\n                index_kind: z.literal('exclusion'),\n                exclusion_operators: z.array(z.string()),\n            }),\n            z.object({ index_kind: z.literal('plain') }),\n        ]),\n    )\n    .and(\n        z.discriminatedUnion('is_partial', [\n            z.object({ is_partial: z.literal(false) }),\n            z.object({\n                is_partial: z.literal(true),\n                partial_predicate: z.string(),\n            }),\n        ]),\n    );\n\nconst reference = z.object({\n    constraint_name: z.string(),\n    attributes: z.array(z.string()),\n    referenced_relation: z.string(),\n    referenced_attributes: z.array(z.string()),\n    on_update: z.enum([\n        'NO ACTION',\n        'RESTRICT',\n        'CASCADE',\n        'SET NULL',\n        'SET DEFAULT',\n    ]),\n    on_delete: z.enum([\n        'NO ACTION',\n        'RESTRICT',\n        'CASCADE',\n        'SET NULL',\n        'SET DEFAULT',\n    ]),\n    comment: z.string().nullable(),\n});\n\nconst relation = z.object({\n    name: z.string(),\n    comment: z.string().nullable(),\n    kind: z.enum(['partitioned_table', 'table', 'view', 'materialized_view']),\n    summary: z.string().optional(),\n    details: z.string().optional(),\n    attributes: z.record(z.string(), relationAttribute),\n    references: z.record(z.string(), reference),\n    indexes: z.record(z.string(), indexInfo),\n});\n\nconst relations = z.record(z.string(), relation);\n\nconst database = z.object({\n    type: z.enum(['postgresql']),\n    name: z.string(),\n    comment: z.string().nullable(),\n    summary: z.string().optional(),\n    details: z.string().optional(),\n    relations: relations,\n});\n"]}

package/dist/validatePaths.d.mts

@@ -0,0 +1,12 @@
+type TPathOptionKey = "sslcert" | "sslkey" | "sslrootcert" | "sshPrivateKey";
+export type TPathValidationError = {
+    option: string;
+    path: string;
+    error: string;
+};
+export declare const validatePathOptions: <T extends Partial<Record<TPathOptionKey, string>>>(options: T) => {
+    errors: TPathValidationError[];
+    expandedPaths: Partial<Record<TPathOptionKey, string>>;
+};
+export {};
+//# sourceMappingURL=validatePaths.d.mts.map

package/dist/validatePaths.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validatePaths.d.mts","sourceRoot":"./src/","sources":["validatePaths.mts"],"names":[],"mappings":"AAQA,KAAK,cAAc,GAAG,SAAS,GAAG,QAAQ,GAAG,aAAa,GAAG,eAAe,CAAC;AAE7E,MAAM,MAAM,oBAAoB,GAAG;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACjB,CAAC;AAyBF,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC,EACjF,SAAS,CAAC,KACX;IAAE,MAAM,EAAE,oBAAoB,EAAE,CAAC;IAAC,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC,CAAA;CAmC1F,CAAC"}

package/dist/validatePaths.mjs

@@ -0,0 +1,48 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+const expandTilde = (path) => path.startsWith("~/") || path === "~"
+    ? path.replace(/^~/, homedir())
+    : path;
+const normalizePath = (path) => resolve(expandTilde(path));
+const validatePathExists = (path) => {
+    const expandedPath = normalizePath(path);
+    return existsSync(expandedPath)
+        ? { valid: true, expandedPath }
+        : { valid: false, error: `Path does not exist: ${path}` };
+};
+const PATH_OPTION_LABELS = {
+    sslcert: "--sslcert",
+    sslkey: "--sslkey",
+    sslrootcert: "--sslrootcert",
+    sshPrivateKey: "--ssh-private-key",
+};
+export const validatePathOptions = (options) => {
+    const pathKeys = ["sslcert", "sslkey", "sslrootcert", "sshPrivateKey"];
+    const results = pathKeys
+        .filter((key) => options[key] !== undefined)
+        .map((key) => {
+        const path = options[key];
+        const result = validatePathExists(path);
+        return {
+            key,
+            path,
+            result,
+        };
+    });
+    const errors = results
+        .filter((r) => !r.result.valid)
+        .map((r) => ({
+        option: PATH_OPTION_LABELS[r.key],
+        path: r.path,
+        error: r.result.error,
+    }));
+    const expandedPaths = results
+        .filter((r) => r.result.valid)
+        .reduce((acc, r) => ({
+        ...acc,
+        [r.key]: r.result.expandedPath,
+    }), {});
+    return { errors, expandedPaths };
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGVQYXRocy5tanMiLCJzb3VyY2VSb290IjoiLi9zcmMvIiwic291cmNlcyI6WyJ2YWxpZGF0ZVBhdGhzLm10cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQ3JDLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxTQUFTLENBQUM7QUFDbEMsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLFdBQVcsQ0FBQztBQWNwQyxNQUFNLFdBQVcsR0FBRyxDQUFDLElBQVksRUFBVSxFQUFFLENBQ3pDLElBQUksQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLElBQUksSUFBSSxLQUFLLEdBQUc7SUFDakMsQ0FBQyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxFQUFFLE9BQU8sRUFBRSxDQUFDO0lBQy9CLENBQUMsQ0FBQyxJQUFJLENBQUM7QUFFZixNQUFNLGFBQWEsR0FBRyxDQUFDLElBQVksRUFBVSxFQUFFLENBQzNDLE9BQU8sQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztBQUUvQixNQUFNLGtCQUFrQixHQUFHLENBQUMsSUFBWSxFQUF5QixFQUFFO0lBQy9ELE1BQU0sWUFBWSxHQUFHLGFBQWEsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUV6QyxPQUFPLFVBQVUsQ0FBQyxZQUFZLENBQUM7UUFDM0IsQ0FBQyxDQUFDLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRSxZQUFZLEVBQUU7UUFDL0IsQ0FBQyxDQUFDLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsd0JBQXdCLElBQUksRUFBRSxFQUFFLENBQUM7QUFDbEUsQ0FBQyxDQUFDO0FBRUYsTUFBTSxrQkFBa0IsR0FBbUM7SUFDdkQsT0FBTyxFQUFFLFdBQVc7SUFDcEIsTUFBTSxFQUFFLFVBQVU7SUFDbEIsV0FBVyxFQUFFLGVBQWU7SUFDNUIsYUFBYSxFQUFFLG1CQUFtQjtDQUNyQyxDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUcsQ0FDL0IsT0FBVSxFQUNnRixFQUFFO0lBQzVGLE1BQU0sUUFBUSxHQUFxQixDQUFDLFNBQVMsRUFBRSxRQUFRLEVBQUUsYUFBYSxFQUFFLGVBQWUsQ0FBQyxDQUFDO0lBRXpGLE1BQU0sT0FBTyxHQUFHLFFBQVE7U0FDbkIsTUFBTSxDQUFDLENBQUMsR0FBRyxFQUFFLEVBQUUsQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLEtBQUssU0FBUyxDQUFDO1NBQzNDLEdBQUcsQ0FBQyxDQUFDLEdBQUcsRUFBRSxFQUFFO1FBQ1QsTUFBTSxJQUFJLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBVyxDQUFDO1FBQ3BDLE1BQU0sTUFBTSxHQUFHLGtCQUFrQixDQUFDLElBQUksQ0FBQyxDQUFDO1FBRXhDLE9BQU87WUFDSCxHQUFHO1lBQ0gsSUFBSTtZQUNKLE1BQU07U0FDVCxDQUFDO0lBQ04sQ0FBQyxDQUFDLENBQUM7SUFFUCxNQUFNLE1BQU0sR0FBRyxPQUFPO1NBQ2pCLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQztTQUM5QixHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFDVCxNQUFNLEVBQUUsa0JBQWtCLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQztRQUNqQyxJQUFJLEVBQUUsQ0FBQyxDQUFDLElBQUk7UUFDWixLQUFLLEVBQUcsQ0FBQyxDQUFDLE1BQTBDLENBQUMsS0FBSztLQUM3RCxDQUFDLENBQUMsQ0FBQztJQUVSLE1BQU0sYUFBYSxHQUFHLE9BQU87U0FDeEIsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQztTQUM3QixNQUFNLENBQ0gsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBQ1QsR0FBRyxHQUFHO1FBQ04sQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLEVBQUcsQ0FBQyxDQUFDLE1BQWdELENBQUMsWUFBWTtLQUM1RSxDQUFDLEVBQ0YsRUFBNkMsQ0FDaEQsQ0FBQztJQUVOLE9BQU8sRUFBRSxNQUFNLEVBQUUsYUFBYSxFQUFFLENBQUM7QUFDckMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZXhpc3RzU3luYyB9IGZyb20gXCJub2RlOmZzXCI7XG5pbXBvcnQgeyBob21lZGlyIH0gZnJvbSBcIm5vZGU6b3NcIjtcbmltcG9ydCB7IHJlc29sdmUgfSBmcm9tIFwibm9kZTpwYXRoXCI7XG5cbnR5cGUgVFBhdGhWYWxpZGF0aW9uUmVzdWx0ID1cbiAgICB8IHsgdmFsaWQ6IHRydWU7IGV4cGFuZGVkUGF0aDogc3RyaW5nIH1cbiAgICB8IHsgdmFsaWQ6IGZhbHNlOyBlcnJvcjogc3RyaW5nIH07XG5cbnR5cGUgVFBhdGhPcHRpb25LZXkgPSBcInNzbGNlcnRcIiB8IFwic3Nsa2V5XCIgfCBcInNzbHJvb3RjZXJ0XCIgfCBcInNzaFByaXZhdGVLZXlcIjtcblxuZXhwb3J0IHR5cGUgVFBhdGhWYWxpZGF0aW9uRXJyb3IgPSB7XG4gICAgb3B0aW9uOiBzdHJpbmc7XG4gICAgcGF0aDogc3RyaW5nO1xuICAgIGVycm9yOiBzdHJpbmc7XG59O1xuXG5jb25zdCBleHBhbmRUaWxkZSA9IChwYXRoOiBzdHJpbmcpOiBzdHJpbmcgPT5cbiAgICBwYXRoLnN0YXJ0c1dpdGgoXCJ+L1wiKSB8fCBwYXRoID09PSBcIn5cIlxuICAgICAgICA/IHBhdGgucmVwbGFjZSgvXn4vLCBob21lZGlyKCkpXG4gICAgICAgIDogcGF0aDtcblxuY29uc3Qgbm9ybWFsaXplUGF0aCA9IChwYXRoOiBzdHJpbmcpOiBzdHJpbmcgPT5cbiAgICByZXNvbHZlKGV4cGFuZFRpbGRlKHBhdGgpKTtcblxuY29uc3QgdmFsaWRhdGVQYXRoRXhpc3RzID0gKHBhdGg6IHN0cmluZyk6IFRQYXRoVmFsaWRhdGlvblJlc3VsdCA9PiB7XG4gICAgY29uc3QgZXhwYW5kZWRQYXRoID0gbm9ybWFsaXplUGF0aChwYXRoKTtcblxuICAgIHJldHVybiBleGlzdHNTeW5jKGV4cGFuZGVkUGF0aClcbiAgICAgICAgPyB7IHZhbGlkOiB0cnVlLCBleHBhbmRlZFBhdGggfVxuICAgICAgICA6IHsgdmFsaWQ6IGZhbHNlLCBlcnJvcjogYFBhdGggZG9lcyBub3QgZXhpc3Q6ICR7cGF0aH1gIH07XG59O1xuXG5jb25zdCBQQVRIX09QVElPTl9MQUJFTFM6IFJlY29yZDxUUGF0aE9wdGlvbktleSwgc3RyaW5nPiA9IHtcbiAgICBzc2xjZXJ0OiBcIi0tc3NsY2VydFwiLFxuICAgIHNzbGtleTogXCItLXNzbGtleVwiLFxuICAgIHNzbHJvb3RjZXJ0OiBcIi0tc3Nscm9vdGNlcnRcIixcbiAgICBzc2hQcml2YXRlS2V5OiBcIi0tc3NoLXByaXZhdGUta2V5XCIsXG59O1xuXG5leHBvcnQgY29uc3QgdmFsaWRhdGVQYXRoT3B0aW9ucyA9IDxUIGV4dGVuZHMgUGFydGlhbDxSZWNvcmQ8VFBhdGhPcHRpb25LZXksIHN0cmluZz4+PihcbiAgICBvcHRpb25zOiBUXG4pOiB7IGVycm9yczogVFBhdGhWYWxpZGF0aW9uRXJyb3JbXTsgZXhwYW5kZWRQYXRoczogUGFydGlhbDxSZWNvcmQ8VFBhdGhPcHRpb25LZXksIHN0cmluZz4+IH0gPT4ge1xuICAgIGNvbnN0IHBhdGhLZXlzOiBUUGF0aE9wdGlvbktleVtdID0gW1wic3NsY2VydFwiLCBcInNzbGtleVwiLCBcInNzbHJvb3RjZXJ0XCIsIFwic3NoUHJpdmF0ZUtleVwiXTtcblxuICAgIGNvbnN0IHJlc3VsdHMgPSBwYXRoS2V5c1xuICAgICAgICAuZmlsdGVyKChrZXkpID0+IG9wdGlvbnNba2V5XSAhPT0gdW5kZWZpbmVkKVxuICAgICAgICAubWFwKChrZXkpID0+IHtcbiAgICAgICAgICAgIGNvbnN0IHBhdGggPSBvcHRpb25zW2tleV0gYXMgc3RyaW5nO1xuICAgICAgICAgICAgY29uc3QgcmVzdWx0ID0gdmFsaWRhdGVQYXRoRXhpc3RzKHBhdGgpO1xuXG4gICAgICAgICAgICByZXR1cm4ge1xuICAgICAgICAgICAgICAgIGtleSxcbiAgICAgICAgICAgICAgICBwYXRoLFxuICAgICAgICAgICAgICAgIHJlc3VsdCxcbiAgICAgICAgICAgIH07XG4gICAgICAgIH0pO1xuXG4gICAgY29uc3QgZXJyb3JzID0gcmVzdWx0c1xuICAgICAgICAuZmlsdGVyKChyKSA9PiAhci5yZXN1bHQudmFsaWQpXG4gICAgICAgIC5tYXAoKHIpID0+ICh7XG4gICAgICAgICAgICBvcHRpb246IFBBVEhfT1BUSU9OX0xBQkVMU1tyLmtleV0sXG4gICAgICAgICAgICBwYXRoOiByLnBhdGgsXG4gICAgICAgICAgICBlcnJvcjogKHIucmVzdWx0IGFzIHsgdmFsaWQ6IGZhbHNlOyBlcnJvcjogc3RyaW5nIH0pLmVycm9yLFxuICAgICAgICB9KSk7XG5cbiAgICBjb25zdCBleHBhbmRlZFBhdGhzID0gcmVzdWx0c1xuICAgICAgICAuZmlsdGVyKChyKSA9PiByLnJlc3VsdC52YWxpZClcbiAgICAgICAgLnJlZHVjZShcbiAgICAgICAgICAgIChhY2MsIHIpID0+ICh7XG4gICAgICAgICAgICAgICAgLi4uYWNjLFxuICAgICAgICAgICAgICAgIFtyLmtleV06IChyLnJlc3VsdCBhcyB7IHZhbGlkOiB0cnVlOyBleHBhbmRlZFBhdGg6IHN0cmluZyB9KS5leHBhbmRlZFBhdGgsXG4gICAgICAgICAgICB9KSxcbiAgICAgICAgICAgIHt9IGFzIFBhcnRpYWw8UmVjb3JkPFRQYXRoT3B0aW9uS2V5LCBzdHJpbmc+PlxuICAgICAgICApO1xuXG4gICAgcmV0dXJuIHsgZXJyb3JzLCBleHBhbmRlZFBhdGhzIH07XG59O1xuIl19

package/package.json

@@ -0,0 +1,43 @@
+{
+    "name": "dbctx",
+    "version": "1.0.0",
+    "description": "dbctx CLI",
+    "type": "module",
+    "main": "dist/index.mjs",
+    "bin": {
+        "dbctx": "./dist/index.mjs"
+    },
+    "scripts": {
+        "start": "tsc && node ./dist/index.mjs",
+        "dev": "tsc --watch --preserveWatchOutput",
+        "build": "tsc",
+        "build:ts:watch": "tsc --watch --preserveWatchOutput"
+    },
+    "keywords": [],
+    "author": {
+        "name": "AirState",
+        "email": "hello@airstate.dev",
+        "url": "https://airstate.dev"
+    },
+    "license": "UNLICENSED",
+    "dependencies": {
+        "commander": "14.0.3",
+        "es-toolkit": "1.44.0",
+        "ink": "6.6.0",
+        "pg": "8.18.0",
+        "react": "19.2.4",
+        "winston": "3.19.0",
+        "zod": "4.3.6"
+    },
+    "devDependencies": {
+        "@types/node": "24.0.0",
+        "@types/pg": "8.16.0",
+        "@types/react": "19.2.10",
+        "concurrently": "9.2.1",
+        "cross-env": "7.0.3",
+        "typescript": "5.9.3"
+    },
+    "volta": {
+        "node": "24.0.0"
+    }
+}

package/src/App.tsx

@@ -0,0 +1,44 @@
+import { Text, Box } from "ink";
+import type { ReactNode } from "react";
+import type { TSSLMode } from "./index.mjs";
+
+export type TConnectionConfig = {
+    connectionString?: string;
+    hostname?: string;
+    port?: number;
+    database?: string;
+    username?: string;
+    sslmode?: TSSLMode;
+    sslcert?: string;
+    sslkey?: string;
+    sslrootcert?: string;
+    sshHost?: string;
+    sshPort?: number;
+    sshUsername?: string;
+    sshPrivateKey?: string;
+};
+
+type TAppProps = {
+    config: TConnectionConfig;
+};
+
+export function App({ config }: TAppProps): ReactNode {
+    const connectionTarget = config.connectionString
+        ? config.connectionString.replace(/:[^:@]+@/, ":***@") // mask password
+        : `${config.hostname}:${config.port}/${config.database}`;
+
+    return (
+        <Box flexDirection="column" padding={1}>
+            <Box marginBottom={1}>
+                <Text color="cyan" bold>
+                    dbctx
+                </Text>
+                <Text dimColor> - AI generated docs from your application database</Text>
+            </Box>
+            <Box>
+                <Text dimColor>Connecting to: </Text>
+                <Text color="yellow">{connectionTarget}</Text>
+            </Box>
+        </Box>
+    );
+}

package/src/components/Error.tsx

@@ -0,0 +1,16 @@
+import { Text, Box } from "ink";
+import type { ReactNode } from "react";
+
+interface ErrorProps {
+    message: string;
+}
+
+export function Error({ message }: ErrorProps): ReactNode {
+    return (
+        <Box>
+            <Text color="red" bold>
+                Error: {message}
+            </Text>
+        </Box>
+    );
+}

package/src/db/analyze.mts

@@ -0,0 +1,22 @@
+import type { Pool } from "pg";
+
+export const analyzeRelation = async (pool: Pool, relationName: string): Promise<void> => {
+    // Validate relation exists and get properly quoted name to prevent SQL injection
+    const validation = await pool.query<{ quoted_name: string }>(
+        `
+        SELECT format('%I', c.relname) AS quoted_name
+        FROM pg_catalog.pg_class c
+        JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+        WHERE n.nspname = 'public'
+            AND c.relname = $1
+            AND c.relkind IN ('r', 'p', 'm')
+        `,
+        [relationName]
+    );
+
+    if (validation.rows.length === 0) {
+        throw new Error(`Relation "${relationName}" not found in public schema`);
+    }
+
+    await pool.query(`ANALYZE public.${validation.rows[0].quoted_name}`);
+};

package/src/db/attributes.mts

@@ -0,0 +1,58 @@
+import type { Pool } from "pg";
+
+export type TAttributeKind = "regular" | "generated";
+
+export type TGeneratedStorage = "stored" | "virtual";
+
+export type TAttributeInfo = {
+    attribute_name: string;
+    data_type: string;
+    is_nullable: boolean;
+    has_default: boolean;
+    default_expression: string | null;
+    kind: TAttributeKind;
+    generated_storage: TGeneratedStorage | null;
+    generated_expression: string | null;
+    comment: string | null;
+};
+
+export const fetchRelationAttributes = async (pool: Pool, relationName: string): Promise<TAttributeInfo[]> => {
+    const result = await pool.query<TAttributeInfo>(
+        `
+        SELECT
+            a.attname AS attribute_name,
+            format_type(a.atttypid, a.atttypemod) AS data_type,
+            NOT a.attnotnull AS is_nullable,
+            ad.adbin IS NOT NULL AS has_default,
+            CASE
+                WHEN a.attgenerated = '' AND ad.adbin IS NOT NULL THEN pg_get_expr(ad.adbin, ad.adrelid)
+                ELSE NULL
+            END AS default_expression,
+            CASE a.attgenerated
+                WHEN '' THEN 'regular'
+                ELSE 'generated'
+            END AS kind,
+            CASE a.attgenerated
+                WHEN 's' THEN 'stored'
+                WHEN 'v' THEN 'virtual'
+                ELSE NULL
+            END AS generated_storage,
+            CASE
+                WHEN a.attgenerated != '' THEN pg_get_expr(ad.adbin, ad.adrelid)
+                ELSE NULL
+            END AS generated_expression,
+            col_description(c.oid, a.attnum) AS comment
+        FROM pg_catalog.pg_class c
+        JOIN pg_catalog.pg_attribute a ON a.attrelid = c.oid
+        LEFT JOIN pg_catalog.pg_attrdef ad ON ad.adrelid = a.attrelid AND ad.adnum = a.attnum
+        WHERE c.relname = $1
+            AND c.relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = 'public')
+            AND a.attnum > 0
+            AND NOT a.attisdropped
+        ORDER BY a.attnum
+        `,
+        [relationName]
+    );
+
+    return result.rows;
+};

package/src/db/enums.mts

@@ -0,0 +1,43 @@
+import type { Pool } from "pg";
+import { groupBy } from "es-toolkit";
+
+type TEnumValueRow = {
+    enum_name: string;
+    value: string;
+    sort_order: number;
+    comment: string | null;
+};
+
+export type TEnumInfo = {
+    values: string[];
+    comment: string | null;
+};
+
+export type TGroupedEnums = Record<string, TEnumInfo>;
+
+export const fetchPublicEnums = async (pool: Pool): Promise<TGroupedEnums> => {
+    const result = await pool.query<TEnumValueRow>(`
+        SELECT
+            t.typname AS enum_name,
+            e.enumlabel AS value,
+            e.enumsortorder AS sort_order,
+            obj_description(t.oid, 'pg_type') AS comment
+        FROM pg_catalog.pg_type t
+        JOIN pg_catalog.pg_enum e ON t.oid = e.enumtypid
+        JOIN pg_catalog.pg_namespace n ON t.typnamespace = n.oid
+        WHERE n.nspname = 'public'
+        ORDER BY enum_name, sort_order
+    `);
+
+    const grouped = groupBy(result.rows, (row) => row.enum_name);
+
+    return Object.fromEntries(
+        Object.entries(grouped).map(([name, rows]) => [
+            name,
+            {
+                values: rows.map((r) => r.value),
+                comment: rows[0]?.comment ?? null,
+            },
+        ])
+    );
+};

package/src/db/file-stats.mts

@@ -0,0 +1,57 @@
+import type { Pool } from "pg";
+
+export type TRelationFileStats = {
+    relation_name: string;
+    file_path: string | null;
+    modification_time: Date;
+    size_bytes: number;
+    is_partitioned: boolean;
+    partition_count: number | null;
+};
+
+export const fetchRelationFileStats = async (pool: Pool, relationName: string): Promise<TRelationFileStats> => {
+    const result = await pool.query<TRelationFileStats>(
+        `
+        WITH target AS (
+            SELECT c.oid, c.relname, c.relkind
+            FROM pg_catalog.pg_class c
+            JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+            WHERE n.nspname = 'public'
+                AND c.relname = $1
+                AND c.relkind IN ('r', 'p', 'm')
+        ),
+        partition_stats AS (
+            SELECT
+                (pg_stat_file(pg_relation_filepath(child.oid))).modification AS modification_time,
+                (pg_stat_file(pg_relation_filepath(child.oid))).size AS size_bytes
+            FROM target t
+            JOIN pg_catalog.pg_inherits i ON i.inhparent = t.oid
+            JOIN pg_catalog.pg_class child ON child.oid = i.inhrelid
+            WHERE t.relkind = 'p'
+        )
+        SELECT
+            t.relname AS relation_name,
+            CASE
+                WHEN t.relkind = 'p' THEN NULL
+                ELSE pg_relation_filepath(t.oid)
+            END AS file_path,
+            CASE
+                WHEN t.relkind = 'p' THEN (SELECT MAX(modification_time) FROM partition_stats)
+                ELSE (pg_stat_file(pg_relation_filepath(t.oid))).modification
+            END AS modification_time,
+            CASE
+                WHEN t.relkind = 'p' THEN (SELECT COALESCE(SUM(size_bytes), 0) FROM partition_stats)
+                ELSE (pg_stat_file(pg_relation_filepath(t.oid))).size
+            END AS size_bytes,
+            t.relkind = 'p' AS is_partitioned,
+            CASE
+                WHEN t.relkind = 'p' THEN (SELECT COUNT(*) FROM partition_stats)
+                ELSE NULL
+            END AS partition_count
+        FROM target t
+        `,
+        [relationName]
+    );
+
+    return result.rows[0];
+};