@neverinfamous/postgres-mcp 1.0.1

package/dist/adapters/postgresql/prompts/kcache.js

@@ -0,0 +1,227 @@
+/**
+ * pg_stat_kcache Setup Prompt
+ *
+ * Complete guide for setting up OS-level performance monitoring with pg_stat_kcache.
+ */
+export function createSetupKcachePrompt() {
+    return {
+        name: "pg_setup_kcache",
+        description: "Complete guide for setting up OS-level CPU and I/O performance monitoring with pg_stat_kcache.",
+        arguments: [
+            {
+                name: "focus",
+                description: "Analysis focus: cpu, io, memory, all",
+                required: false,
+            },
+        ],
+        // eslint-disable-next-line @typescript-eslint/require-await
+        handler: async (args, _context) => {
+            const focus = args["focus"] ?? "all";
+            return `# pg_stat_kcache Setup Guide - ${focus.toUpperCase()} Analysis
+
+## pg_stat_kcache Overview
+
+pg_stat_kcache extends pg_stat_statements with OS-level metrics:
+- **CPU time** (user + system)
+- **I/O statistics** (reads/writes)
+- **Memory faults** (minor/major page faults)
+
+This enables identifying whether queries are:
+- **CPU-bound** — High CPU time, low I/O
+- **I/O-bound** — High I/O, lower CPU time
+- **Memory-bound** — High page faults
+
+## Prerequisites
+
+pg_stat_kcache requires **pg_stat_statements** to be installed first.
+
+## Setup Steps
+
+### 1. Configure postgresql.conf
+
+\`\`\`
+# Both extensions required in shared_preload_libraries
+shared_preload_libraries = 'pg_stat_statements,pg_stat_kcache'
+
+# pg_stat_statements settings
+pg_stat_statements.track = all
+pg_stat_statements.max = 10000
+\`\`\`
+
+**Restart PostgreSQL after configuration!**
+
+### 2. Install Extensions
+
+\`\`\`sql
+-- Must install pg_stat_statements first
+CREATE EXTENSION IF NOT EXISTS pg_stat_statements;
+CREATE EXTENSION IF NOT EXISTS pg_stat_kcache;
+
+-- Verify installation
+SELECT * FROM pg_extension WHERE extname IN ('pg_stat_statements', 'pg_stat_kcache');
+\`\`\`
+
+### 3. Understanding the Metrics
+
+| Metric | Description | Unit |
+|--------|-------------|------|
+| \`user_time\` | CPU time in user mode | seconds |
+| \`system_time\` | CPU time in kernel mode | seconds |
+| \`reads\` | Bytes read from disk | bytes |
+| \`writes\` | Bytes written to disk | bytes |
+| \`minflts\` | Minor page faults (soft) | count |
+| \`majflts\` | Major page faults (hard) | count |
+
+${focus === "cpu" || focus === "all"
+                ? `
+### 4. CPU Analysis
+
+**Find CPU-intensive queries:**
+\`\`\`sql
+SELECT 
+    substring(query, 1, 80) as query_preview,
+    calls,
+    round((user_time + system_time)::numeric, 3) as total_cpu_sec,
+    round(((user_time + system_time) / calls)::numeric, 6) as cpu_per_call
+FROM pg_stat_kcache k
+JOIN pg_stat_statements s USING (queryid, dbid, userid)
+ORDER BY (user_time + system_time) DESC
+LIMIT 10;
+\`\`\`
+
+Or use: \`pg_kcache_top_cpu\`
+
+**CPU-bound indicators:**
+- High user_time + system_time
+- Low reads/writes relative to CPU
+- Common causes: complex calculations, string operations, JSON processing
+`
+                : ""}
+
+${focus === "io" || focus === "all"
+                ? `
+### 5. I/O Analysis
+
+**Find I/O-intensive queries:**
+\`\`\`sql
+SELECT 
+    substring(query, 1, 80) as query_preview,
+    calls,
+    pg_size_pretty(reads::bigint) as total_reads,
+    pg_size_pretty(writes::bigint) as total_writes,
+    pg_size_pretty((reads / NULLIF(calls, 0))::bigint) as reads_per_call
+FROM pg_stat_kcache k
+JOIN pg_stat_statements s USING (queryid, dbid, userid)
+ORDER BY reads DESC
+LIMIT 10;
+\`\`\`
+
+Or use: \`pg_kcache_top_io\`
+
+**I/O-bound indicators:**
+- High reads/writes
+- Lower CPU time relative to I/O
+- Common causes: sequential scans, missing indexes, large result sets
+`
+                : ""}
+
+${focus === "memory" || focus === "all"
+                ? `
+### 6. Memory Analysis
+
+**Find queries with memory pressure:**
+\`\`\`sql
+SELECT 
+    substring(query, 1, 80) as query_preview,
+    calls,
+    minflts as minor_page_faults,
+    majflts as major_page_faults,
+    minflts / NULLIF(calls, 0) as minflts_per_call
+FROM pg_stat_kcache k
+JOIN pg_stat_statements s USING (queryid, dbid, userid)
+ORDER BY majflts DESC
+LIMIT 10;
+\`\`\`
+
+**Memory-bound indicators:**
+- High major page faults (disk access for memory)
+- High minor faults relative to data size
+- Common causes: insufficient shared_buffers, work_mem too low
+`
+                : ""}
+
+### 7. Resource Classification
+
+Use \`pg_kcache_resource_analysis\` to automatically classify queries:
+
+\`\`\`sql
+-- Classify as CPU-bound vs I/O-bound
+WITH metrics AS (
+    SELECT 
+        queryid,
+        (user_time + system_time) as cpu_time,
+        reads + writes as io_bytes
+    FROM pg_stat_kcache
+)
+SELECT 
+    CASE 
+        WHEN cpu_time > io_bytes / 1000000 THEN 'CPU-bound'
+        ELSE 'I/O-bound'
+    END as classification,
+    COUNT(*) as query_count
+FROM metrics
+GROUP BY 1;
+\`\`\`
+
+## Available Tools
+
+| Tool | Purpose |
+|------|---------|
+| \`pg_kcache_create_extension\` | Enable pg_stat_kcache |
+| \`pg_kcache_query_stats\` | Query stats with CPU/IO |
+| \`pg_kcache_top_cpu\` | Top CPU consumers |
+| \`pg_kcache_top_io\` | Top I/O consumers |
+| \`pg_kcache_database_stats\` | Database-level aggregates |
+| \`pg_kcache_resource_analysis\` | CPU vs I/O classification |
+| \`pg_kcache_reset\` | Reset statistics |
+
+## Optimization Strategies
+
+### CPU-Bound Queries
+1. Simplify complex expressions
+2. Move computation to application layer
+3. Consider materialized views for expensive calculations
+4. Check for inefficient functions
+
+### I/O-Bound Queries
+1. Add missing indexes
+2. Reduce result set size with better filtering
+3. Use covering indexes to avoid heap fetches
+4. Consider partitioning for large tables
+
+### Memory-Bound Queries
+1. Increase \`shared_buffers\`
+2. Increase \`work_mem\` for sorts/hashes
+3. Use \`LIMIT\` to reduce memory pressure
+4. Consider query restructuring
+
+## Best Practices
+
+1. **Reset stats periodically** — Analyze recent workload
+2. **Correlate with pg_stat_statements** — Full picture
+3. **Monitor during peak hours** — Realistic workload
+4. **Track over time** — Identify regressions
+5. **Use with EXPLAIN ANALYZE** — Validate findings
+
+## Common Pitfalls
+
+- ❌ Forgetting pg_stat_statements prerequisite
+- ❌ Not restarting after shared_preload_libraries change
+- ❌ Analyzing stale statistics
+- ❌ Ignoring the difference between user and system CPU
+
+**Pro Tip:** Combine pg_stat_kcache with EXPLAIN (ANALYZE, BUFFERS) for complete query diagnostics!`;
+        },
+    };
+}
+//# sourceMappingURL=kcache.js.map

package/dist/adapters/postgresql/prompts/kcache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kcache.js","sourceRoot":"","sources":["../../../../src/adapters/postgresql/prompts/kcache.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,MAAM,UAAU,uBAAuB;IACrC,OAAO;QACL,IAAI,EAAE,iBAAiB;QACvB,WAAW,EACT,gGAAgG;QAClG,SAAS,EAAE;YACT;gBACE,IAAI,EAAE,OAAO;gBACb,WAAW,EAAE,sCAAsC;gBACnD,QAAQ,EAAE,KAAK;aAChB;SACF;QACD,4DAA4D;QAC5D,OAAO,EAAE,KAAK,EACZ,IAA4B,EAC5B,QAAwB,EACP,EAAE;YACnB,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC;YAErC,OAAO,kCAAkC,KAAK,CAAC,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwDhE,KAAK,KAAK,KAAK,IAAI,KAAK,KAAK,KAAK;gBAChC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;CAsBL;gBACG,CAAC,CAAC,EACN;;EAGE,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,KAAK;gBAC/B,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;CAuBL;gBACG,CAAC,CAAC,EACN;;EAGE,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,KAAK;gBACnC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;CAqBL;gBACG,CAAC,CAAC,EACN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oGAwEoG,CAAC;QACjG,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/adapters/postgresql/prompts/ltree.d.ts

@@ -0,0 +1,8 @@
+/**
+ * ltree Setup Prompt
+ *
+ * Complete guide for setting up hierarchical data with ltree.
+ */
+import type { PromptDefinition } from "../../../types/index.js";
+export declare function createSetupLtreePrompt(): PromptDefinition;
+//# sourceMappingURL=ltree.d.ts.map

package/dist/adapters/postgresql/prompts/ltree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ltree.d.ts","sourceRoot":"","sources":["../../../../src/adapters/postgresql/prompts/ltree.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAkB,MAAM,yBAAyB,CAAC;AAEhF,wBAAgB,sBAAsB,IAAI,gBAAgB,CA2RzD"}

package/dist/adapters/postgresql/prompts/ltree.js

@@ -0,0 +1,286 @@
+/**
+ * ltree Setup Prompt
+ *
+ * Complete guide for setting up hierarchical data with ltree.
+ */
+export function createSetupLtreePrompt() {
+    return {
+        name: "pg_setup_ltree",
+        description: "Complete guide for setting up hierarchical tree-structured data with ltree for categories, org charts, and file paths.",
+        arguments: [
+            {
+                name: "useCase",
+                description: "Use case: categories, org_chart, file_paths, taxonomy",
+                required: false,
+            },
+        ],
+        // eslint-disable-next-line @typescript-eslint/require-await
+        handler: async (args, _context) => {
+            const useCase = args["useCase"] ?? "categories";
+            let exampleTable = "";
+            let exampleData = "";
+            if (useCase === "categories") {
+                exampleTable = `CREATE TABLE categories (
+    id SERIAL PRIMARY KEY,
+    name VARCHAR(255) NOT NULL,
+    path LTREE NOT NULL,
+    created_at TIMESTAMPTZ DEFAULT NOW()
+);`;
+                exampleData = `INSERT INTO categories (name, path) VALUES
+('Electronics', 'electronics'),
+('Computers', 'electronics.computers'),
+('Laptops', 'electronics.computers.laptops'),
+('Desktops', 'electronics.computers.desktops'),
+('Phones', 'electronics.phones'),
+('Smartphones', 'electronics.phones.smartphones'),
+('Clothing', 'clothing'),
+('Men', 'clothing.men'),
+('Women', 'clothing.women');`;
+            }
+            else if (useCase === "org_chart") {
+                exampleTable = `CREATE TABLE employees (
+    id SERIAL PRIMARY KEY,
+    name VARCHAR(255) NOT NULL,
+    title VARCHAR(100),
+    org_path LTREE NOT NULL,
+    created_at TIMESTAMPTZ DEFAULT NOW()
+);`;
+                exampleData = `INSERT INTO employees (name, title, org_path) VALUES
+('Alice', 'CEO', 'ceo'),
+('Bob', 'CTO', 'ceo.cto'),
+('Carol', 'CFO', 'ceo.cfo'),
+('Dave', 'Engineering Manager', 'ceo.cto.eng'),
+('Eve', 'Senior Developer', 'ceo.cto.eng.dev1'),
+('Frank', 'Junior Developer', 'ceo.cto.eng.dev2'),
+('Grace', 'Finance Manager', 'ceo.cfo.finance');`;
+            }
+            else if (useCase === "file_paths") {
+                exampleTable = `CREATE TABLE files (
+    id SERIAL PRIMARY KEY,
+    name VARCHAR(255) NOT NULL,
+    file_type VARCHAR(50),
+    path LTREE NOT NULL,
+    size_bytes BIGINT,
+    created_at TIMESTAMPTZ DEFAULT NOW()
+);`;
+                exampleData = `INSERT INTO files (name, file_type, path, size_bytes) VALUES
+('home', 'directory', 'home', 0),
+('user1', 'directory', 'home.user1', 0),
+('documents', 'directory', 'home.user1.documents', 0),
+('report.pdf', 'file', 'home.user1.documents.report_pdf', 1024),
+('photos', 'directory', 'home.user1.photos', 0),
+('vacation.jpg', 'file', 'home.user1.photos.vacation_jpg', 2048);`;
+            }
+            else {
+                exampleTable = `CREATE TABLE species (
+    id SERIAL PRIMARY KEY,
+    name VARCHAR(255) NOT NULL,
+    scientific_name VARCHAR(255),
+    taxonomy LTREE NOT NULL,
+    created_at TIMESTAMPTZ DEFAULT NOW()
+);`;
+                exampleData = `INSERT INTO species (name, scientific_name, taxonomy) VALUES
+('Animals', NULL, 'animalia'),
+('Mammals', NULL, 'animalia.mammalia'),
+('Primates', NULL, 'animalia.mammalia.primates'),
+('Human', 'Homo sapiens', 'animalia.mammalia.primates.homo_sapiens'),
+('Carnivora', NULL, 'animalia.mammalia.carnivora'),
+('Dog', 'Canis familiaris', 'animalia.mammalia.carnivora.canis_familiaris'),
+('Cat', 'Felis catus', 'animalia.mammalia.carnivora.felis_catus');`;
+            }
+            return `# ltree Setup Guide - ${useCase
+                .split("_")
+                .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+                .join(" ")}
+
+## ltree Overview
+
+ltree provides **hierarchical label tree** storage for PostgreSQL:
+- Efficient ancestor/descendant queries
+- Pattern matching with lquery
+- Full-text search with ltxtquery
+- GiST index support
+
+**Perfect for:** Categories, org charts, threaded comments, file systems, taxonomies
+
+## Setup Steps
+
+### 1. Install ltree
+
+\`\`\`sql
+CREATE EXTENSION IF NOT EXISTS ltree;
+SELECT * FROM pg_extension WHERE extname = 'ltree';
+\`\`\`
+
+### 2. Create Table with ltree
+
+\`\`\`sql
+${exampleTable}
+
+-- Create GiST index for fast hierarchical queries
+CREATE INDEX idx_path_gist ON ${useCase === "org_chart" ? "employees" : useCase === "file_paths" ? "files" : useCase === "taxonomy" ? "species" : "categories"} USING GIST (${useCase === "org_chart" ? "org_path" : useCase === "taxonomy" ? "taxonomy" : "path"});
+\`\`\`
+
+### 3. Insert Hierarchical Data
+
+\`\`\`sql
+${exampleData}
+\`\`\`
+
+### 4. Path Syntax
+
+ltree labels:
+- Use \`.\` as separator
+- Labels can contain letters, numbers, underscores
+- Case-sensitive
+- Up to 256 labels per path
+
+\`\`\`
+electronics.computers.laptops.gaming
+    ^          ^        ^        ^
+    |          |        |        |
+  level 1   level 2  level 3  level 4
+\`\`\`
+
+### 5. Hierarchical Queries
+
+**Find all descendants (children, grandchildren, etc.):**
+\`\`\`sql
+-- All items under 'electronics.computers'
+SELECT * FROM categories
+WHERE path <@ 'electronics.computers';
+
+-- Or using the tool:
+-- pg_ltree_query(table_name: "categories", column_name: "path", 
+--                base_path: "electronics.computers", query_type: "descendants")
+\`\`\`
+
+**Find all ancestors (parents, grandparents, etc.):**
+\`\`\`sql
+-- All parents of 'electronics.computers.laptops'
+SELECT * FROM categories
+WHERE path @> 'electronics.computers.laptops';
+
+-- Or using the tool:
+-- pg_ltree_query(..., query_type: "ancestors")
+\`\`\`
+
+**Find direct children only:**
+\`\`\`sql
+SELECT * FROM categories
+WHERE path ~ 'electronics.*{1}';
+\`\`\`
+
+### 6. Pattern Matching (lquery)
+
+lquery uses special syntax for pattern matching:
+
+| Pattern | Meaning |
+|---------|---------|
+| \`*\` | Match any single label |
+| \`*{n}\` | Match exactly n labels |
+| \`*{n,}\` | Match n or more labels |
+| \`*{n,m}\` | Match between n and m labels |
+| \`word\` | Match exact label |
+| \`word*\` | Match label starting with word |
+| \`%word%\` | Match label containing word |
+
+\`\`\`sql
+-- Find all leaf nodes (no children)
+SELECT path FROM categories c1
+WHERE NOT EXISTS (
+    SELECT 1 FROM categories c2 
+    WHERE c2.path <@ c1.path AND c2.path != c1.path
+);
+
+-- Match pattern: electronics.*.laptops
+SELECT * FROM categories WHERE path ~ 'electronics.*.laptops';
+
+-- Match 2-3 levels deep under electronics
+SELECT * FROM categories WHERE path ~ 'electronics.*{2,3}';
+\`\`\`
+
+Use \`pg_ltree_match\` for pattern matching.
+
+### 7. Common Ancestor
+
+\`\`\`sql
+-- Find longest common ancestor of multiple paths
+SELECT lca('electronics.computers.laptops', 'electronics.phones.smartphones');
+-- Result: 'electronics'
+\`\`\`
+
+Use \`pg_ltree_lca\` for this operation.
+
+### 8. Subpath Extraction
+
+\`\`\`sql
+-- Get subpath from position 1 for 2 labels
+SELECT subpath('electronics.computers.laptops', 1, 2);
+-- Result: 'computers.laptops'
+
+-- Get number of labels
+SELECT nlevel('electronics.computers.laptops');
+-- Result: 3
+\`\`\`
+
+Use \`pg_ltree_subpath\` for extraction.
+
+## Available Tools
+
+| Tool | Purpose |
+|------|---------|
+| \`pg_ltree_create_extension\` | Enable ltree |
+| \`pg_ltree_query\` | Query ancestors/descendants |
+| \`pg_ltree_subpath\` | Extract path segments |
+| \`pg_ltree_lca\` | Find common ancestor |
+| \`pg_ltree_match\` | Pattern matching |
+| \`pg_ltree_list_columns\` | List ltree columns |
+| \`pg_ltree_convert_column\` | Convert text to ltree |
+| \`pg_ltree_create_index\` | Create GiST index |
+
+## Indexing
+
+\`\`\`sql
+-- GiST index for hierarchical queries (recommended)
+CREATE INDEX ON categories USING GIST (path);
+
+-- B-tree for exact matches and sorting
+CREATE INDEX ON categories (path);
+
+-- GIN for full-text search in paths
+CREATE INDEX ON categories USING GIN (path);
+\`\`\`
+
+## Best Practices
+
+1. **Use GiST indexes** — Essential for hierarchical queries
+2. **Keep labels short** — Long labels impact performance
+3. **Use underscores not spaces** — Labels can't contain spaces
+4. **Normalize paths** — Lowercase recommended for consistency
+5. **Validate input** — Ensure path format before insert
+6. **Consider path length** — Very deep hierarchies can be slow
+
+## Common Pitfalls
+
+- ❌ Forgetting GiST index (queries become slow)
+- ❌ Using spaces or special chars in labels
+- ❌ Not validating path format on insert
+- ❌ Circular references (ltree doesn't prevent them)
+- ❌ Moving nodes without updating all descendants
+
+## Comparison with Adjacency List
+
+| Feature | ltree | Adjacency List (parent_id) |
+|---------|-------|---------------------------|
+| Find descendants | ✓ Fast with index | Slow (recursive CTE) |
+| Find ancestors | ✓ Fast with index | Slow (recursive CTE) |
+| Move subtree | Requires updating all paths | Update one parent_id |
+| Storage | Path in each row | Single integer |
+| Insert | Simple | Simple |
+
+**Pro Tip:** For ${useCase}, ltree queries are 10-100x faster than recursive CTEs for large hierarchies!`;
+        },
+    };
+}
+//# sourceMappingURL=ltree.js.map

package/dist/adapters/postgresql/prompts/ltree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ltree.js","sourceRoot":"","sources":["../../../../src/adapters/postgresql/prompts/ltree.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,MAAM,UAAU,sBAAsB;IACpC,OAAO;QACL,IAAI,EAAE,gBAAgB;QACtB,WAAW,EACT,wHAAwH;QAC1H,SAAS,EAAE;YACT;gBACE,IAAI,EAAE,SAAS;gBACf,WAAW,EAAE,uDAAuD;gBACpE,QAAQ,EAAE,KAAK;aAChB;SACF;QACD,4DAA4D;QAC5D,OAAO,EAAE,KAAK,EACZ,IAA4B,EAC5B,QAAwB,EACP,EAAE;YACnB,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,YAAY,CAAC;YAEhD,IAAI,YAAY,GAAG,EAAE,CAAC;YACtB,IAAI,WAAW,GAAG,EAAE,CAAC;YAErB,IAAI,OAAO,KAAK,YAAY,EAAE,CAAC;gBAC7B,YAAY,GAAG;;;;;GAKpB,CAAC;gBACI,WAAW,GAAG;;;;;;;;;6BASO,CAAC;YACxB,CAAC;iBAAM,IAAI,OAAO,KAAK,WAAW,EAAE,CAAC;gBACnC,YAAY,GAAG;;;;;;GAMpB,CAAC;gBACI,WAAW,GAAG;;;;;;;iDAO2B,CAAC;YAC5C,CAAC;iBAAM,IAAI,OAAO,KAAK,YAAY,EAAE,CAAC;gBACpC,YAAY,GAAG;;;;;;;GAOpB,CAAC;gBACI,WAAW,GAAG;;;;;;kEAM4C,CAAC;YAC7D,CAAC;iBAAM,CAAC;gBACN,YAAY,GAAG;;;;;;GAMpB,CAAC;gBACI,WAAW,GAAG;;;;;;;mEAO6C,CAAC;YAC9D,CAAC;YAED,OAAO,yBAAyB,OAAO;iBACpC,KAAK,CAAC,GAAG,CAAC;iBACV,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;iBAClD,IAAI,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;EAwBhB,YAAY;;;gCAGkB,OAAO,KAAK,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,OAAO,KAAK,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,KAAK,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,YAAY,gBAAgB,OAAO,KAAK,WAAW,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,KAAK,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM;;;;;;EAM/P,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA2JM,OAAO,+EAA+E,CAAC;QACtG,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/adapters/postgresql/prompts/partman.d.ts

@@ -0,0 +1,8 @@
+/**
+ * pg_partman Setup Prompt
+ *
+ * Complete guide for setting up automated partition management with pg_partman.
+ */
+import type { PromptDefinition } from "../../../types/index.js";
+export declare function createSetupPartmanPrompt(): PromptDefinition;
+//# sourceMappingURL=partman.d.ts.map

package/dist/adapters/postgresql/prompts/partman.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partman.d.ts","sourceRoot":"","sources":["../../../../src/adapters/postgresql/prompts/partman.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAkB,MAAM,yBAAyB,CAAC;AAEhF,wBAAgB,wBAAwB,IAAI,gBAAgB,CAmN3D"}