@neverinfamous/postgres-mcp 1.0.1

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

@@ -0,0 +1,299 @@
+/**
+ * pgcrypto Setup Prompt
+ *
+ * Complete guide for setting up cryptographic functions with pgcrypto.
+ */
+export function createSetupPgcryptoPrompt() {
+    return {
+        name: "pg_setup_pgcrypto",
+        description: "Complete guide for setting up cryptographic functions with pgcrypto including hashing, encryption, and secure password storage.",
+        arguments: [
+            {
+                name: "useCase",
+                description: "Use case: password_hashing, encryption, uuid, hmac",
+                required: false,
+            },
+        ],
+        // eslint-disable-next-line @typescript-eslint/require-await
+        handler: async (args, _context) => {
+            const useCase = args["useCase"] ?? "password_hashing";
+            return `# pgcrypto Setup Guide - ${useCase
+                .split("_")
+                .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+                .join(" ")}
+
+## pgcrypto Overview
+
+pgcrypto provides cryptographic functions for PostgreSQL:
+- **Hashing:** SHA-256, SHA-512, MD5, etc.
+- **Password hashing:** bcrypt, scrypt (via crypt/gen_salt)
+- **Symmetric encryption:** AES with PGP
+- **Random generation:** Secure UUIDs, random bytes
+- **HMAC:** Message authentication
+
+## Setup Steps
+
+### 1. Install pgcrypto
+
+\`\`\`sql
+CREATE EXTENSION IF NOT EXISTS pgcrypto;
+SELECT * FROM pg_extension WHERE extname = 'pgcrypto';
+\`\`\`
+
+${useCase === "password_hashing"
+                ? `
+### 2. Secure Password Storage
+
+**The RIGHT way: bcrypt with crypt()**
+
+\`\`\`sql
+-- Store password hash
+INSERT INTO users (email, password_hash)
+VALUES (
+    'user@example.com',
+    crypt('mypassword', gen_salt('bf', 10))  -- bcrypt with cost 10
+);
+
+-- Verify password
+SELECT id, email FROM users
+WHERE email = 'user@example.com'
+  AND password_hash = crypt('mypassword', password_hash);
+\`\`\`
+
+**Salt algorithms:**
+| Algorithm | \`gen_salt()\` | Security | Speed |
+|-----------|--------------|----------|-------|
+| bcrypt | \`'bf'\` | ✓ Best | Slowest (good!) |
+| DES extended | \`'xdes'\` | ✗ Weak | Fast |
+| MD5 | \`'md5'\` | ✗ Avoid | Fast |
+
+**bcrypt cost factors:**
+\`\`\`sql
+SELECT gen_salt('bf', 8);   -- Faster, less secure
+SELECT gen_salt('bf', 10);  -- Good balance (recommended)
+SELECT gen_salt('bf', 12);  -- Slower, more secure
+SELECT gen_salt('bf', 14);  -- Very slow, very secure
+\`\`\`
+
+**Complete user table:**
+\`\`\`sql
+CREATE TABLE users (
+    id SERIAL PRIMARY KEY,
+    email CITEXT UNIQUE NOT NULL,
+    password_hash TEXT NOT NULL,
+    created_at TIMESTAMPTZ DEFAULT NOW(),
+    last_login TIMESTAMPTZ
+);
+
+-- Hash on insert
+CREATE OR REPLACE FUNCTION hash_password()
+RETURNS TRIGGER AS $$
+BEGIN
+    IF NEW.password_hash !~ '^\\$2[aby]\\$' THEN
+        NEW.password_hash := crypt(NEW.password_hash, gen_salt('bf', 10));
+    END IF;
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER hash_password_trigger
+    BEFORE INSERT OR UPDATE OF password_hash ON users
+    FOR EACH ROW EXECUTE FUNCTION hash_password();
+\`\`\`
+`
+                : useCase === "encryption"
+                    ? `
+### 2. Symmetric Encryption (AES)
+
+**Encrypt sensitive data:**
+\`\`\`sql
+-- Encrypt with AES (via PGP symmetric)
+INSERT INTO secrets (name, encrypted_value)
+VALUES (
+    'api_key',
+    pgp_sym_encrypt('sk-1234567890abcdef', 'my-encryption-key')
+);
+
+-- Decrypt
+SELECT name, pgp_sym_decrypt(encrypted_value, 'my-encryption-key') as value
+FROM secrets
+WHERE name = 'api_key';
+\`\`\`
+
+**Table design for encrypted data:**
+\`\`\`sql
+CREATE TABLE secrets (
+    id SERIAL PRIMARY KEY,
+    name VARCHAR(255) UNIQUE NOT NULL,
+    encrypted_value BYTEA NOT NULL,  -- Encrypted data is binary
+    created_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- Create index on name (can't index encrypted content)
+CREATE INDEX ON secrets (name);
+\`\`\`
+
+**Encryption options:**
+\`\`\`sql
+-- With compression
+SELECT pgp_sym_encrypt('data', 'key', 'compress-algo=1');
+
+-- With specific cipher
+SELECT pgp_sym_encrypt('data', 'key', 'cipher-algo=aes256');
+\`\`\`
+
+**⚠️ Key management is crucial:**
+- Never hardcode keys in SQL
+- Use environment variables or key management service
+- Rotate keys periodically
+- Consider column-level encryption only for truly sensitive data
+`
+                    : useCase === "uuid"
+                        ? `
+### 2. Secure UUID Generation
+
+**Generate UUID v4 (random):**
+\`\`\`sql
+SELECT gen_random_uuid();
+-- Result: 550e8400-e29b-41d4-a716-446655440000
+
+-- Use as primary key
+CREATE TABLE sessions (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    user_id INTEGER REFERENCES users(id),
+    token TEXT NOT NULL,
+    expires_at TIMESTAMPTZ NOT NULL,
+    created_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- Insert without specifying ID
+INSERT INTO sessions (user_id, token, expires_at)
+VALUES (1, gen_random_bytes(32)::text, NOW() + INTERVAL '24 hours')
+RETURNING id;
+\`\`\`
+
+**PostgreSQL 13+ has built-in gen_random_uuid()**
+For older versions, pgcrypto provides it.
+
+**Random bytes for tokens:**
+\`\`\`sql
+-- Generate secure token (32 bytes = 256 bits)
+SELECT encode(gen_random_bytes(32), 'hex') as token;
+
+-- URL-safe base64 token
+SELECT translate(
+    encode(gen_random_bytes(32), 'base64'),
+    '+/', '-_'
+) as token;
+\`\`\`
+`
+                        : `
+### 2. HMAC for Message Authentication
+
+**Sign data with HMAC:**
+\`\`\`sql
+-- Create HMAC-SHA256 signature
+SELECT encode(
+    hmac('message to sign', 'secret-key', 'sha256'),
+    'hex'
+) as signature;
+
+-- Verify signature
+SELECT encode(hmac('message to sign', 'secret-key', 'sha256'), 'hex')
+    = 'expected_signature_hex';
+\`\`\`
+
+**Webhook signature verification:**
+\`\`\`sql
+CREATE OR REPLACE FUNCTION verify_webhook_signature(
+    payload TEXT,
+    signature TEXT,
+    secret TEXT
+) RETURNS BOOLEAN AS $$
+BEGIN
+    RETURN encode(hmac(payload, secret, 'sha256'), 'hex') = signature;
+END;
+$$ LANGUAGE plpgsql IMMUTABLE;
+
+-- Use in webhook processing
+SELECT * FROM webhooks
+WHERE verify_webhook_signature(body, header_signature, webhook_secret);
+\`\`\`
+
+**HMAC algorithms:**
+| Algorithm | Function | Output Size |
+|-----------|----------|-------------|
+| SHA-256 | \`hmac(data, key, 'sha256')\` | 32 bytes |
+| SHA-512 | \`hmac(data, key, 'sha512')\` | 64 bytes |
+| SHA-384 | \`hmac(data, key, 'sha384')\` | 48 bytes |
+`}
+
+### 3. Data Hashing
+
+**For data integrity (not passwords!):**
+\`\`\`sql
+-- SHA-256 hash
+SELECT encode(digest('data to hash', 'sha256'), 'hex');
+
+-- SHA-512 hash
+SELECT encode(digest('data to hash', 'sha512'), 'hex');
+
+-- MD5 (only for checksums, NOT security)
+SELECT encode(digest('data', 'md5'), 'hex');
+\`\`\`
+
+**Hash algorithms:**
+| Algorithm | Security | Use Case |
+|-----------|----------|----------|
+| SHA-256 | ✓ Good | Data integrity, fingerprints |
+| SHA-512 | ✓ Better | Higher security needs |
+| MD5 | ✗ Broken | Legacy checksums only |
+| SHA-1 | ✗ Weak | Avoid |
+
+## Available Tools
+
+| Tool | Purpose |
+|------|---------|
+| \`pg_pgcrypto_create_extension\` | Enable pgcrypto |
+| \`pg_pgcrypto_hash\` | Hash data with digest() |
+| \`pg_pgcrypto_hmac\` | HMAC authentication |
+| \`pg_pgcrypto_encrypt\` | Symmetric encryption |
+| \`pg_pgcrypto_decrypt\` | Symmetric decryption |
+| \`pg_pgcrypto_gen_random_uuid\` | Generate UUID v4 |
+| \`pg_pgcrypto_gen_random_bytes\` | Generate random bytes |
+| \`pg_pgcrypto_gen_salt\` | Generate salt |
+| \`pg_pgcrypto_crypt\` | Password hashing |
+
+## Security Best Practices
+
+1. **Passwords:** Always use bcrypt via \`crypt()\` with cost ≥10
+2. **Encryption keys:** Never store in database or code
+3. **Random data:** Use \`gen_random_bytes()\`, never \`random()\`
+4. **Hashing:** SHA-256 minimum, avoid MD5/SHA-1
+5. **Salt:** Generated fresh for each password
+6. **Key rotation:** Plan for changing encryption keys
+
+## Common Pitfalls
+
+- ❌ Using MD5 or SHA-1 for passwords (use bcrypt!)
+- ❌ Storing encryption keys in the database
+- ❌ Using predictable values instead of \`gen_random_bytes()\`
+- ❌ Low bcrypt cost factor (use at least 10)
+- ❌ Encrypting everything (performance impact)
+
+## When to Use What
+
+| Need | Solution |
+|------|----------|
+| Password storage | \`crypt()\` + \`gen_salt('bf')\` |
+| Data integrity | \`digest(data, 'sha256')\` |
+| Message authentication | \`hmac(data, key, 'sha256')\` |
+| Sensitive data at rest | \`pgp_sym_encrypt()\` |
+| Unique identifiers | \`gen_random_uuid()\` |
+| Session tokens | \`gen_random_bytes(32)\` |
+
+**Pro Tip:** pgcrypto + citext = secure authentication done right!`;
+        },
+    };
+}
+//# sourceMappingURL=pgcrypto.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pgcrypto.js","sourceRoot":"","sources":["../../../../src/adapters/postgresql/prompts/pgcrypto.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,MAAM,UAAU,yBAAyB;IACvC,OAAO;QACL,IAAI,EAAE,mBAAmB;QACzB,WAAW,EACT,iIAAiI;QACnI,SAAS,EAAE;YACT;gBACE,IAAI,EAAE,SAAS;gBACf,WAAW,EAAE,oDAAoD;gBACjE,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,kBAAkB,CAAC;YAEtD,OAAO,4BAA4B,OAAO;iBACvC,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;;;;;;;;;;;;;;;;;;;;EAqBhB,OAAO,KAAK,kBAAkB;gBAC5B,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2DL;gBACG,CAAC,CAAC,OAAO,KAAK,YAAY;oBACxB,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6CP;oBACK,CAAC,CAAC,OAAO,KAAK,MAAM;wBAClB,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCT;wBACO,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mEAkEmE,CAAC;QAChE,CAAC;KACF,CAAC;AACJ,CAAC"}

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

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

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

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

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

@@ -0,0 +1,148 @@
+/**
+ * pgvector Setup Prompt
+ *
+ * Complete guide for setting up semantic search with pgvector.
+ */
+export function createSetupPgvectorPrompt() {
+    return {
+        name: "pg_setup_pgvector",
+        description: "Complete guide for setting up semantic search with pgvector including table design, indexing, and queries.",
+        arguments: [
+            {
+                name: "contentType",
+                description: "Type of content: documents, products, images",
+                required: false,
+            },
+            {
+                name: "dimensions",
+                description: "Embedding dimensions (default: 1536 for OpenAI ada-002)",
+                required: false,
+            },
+            {
+                name: "distanceMetric",
+                description: "Distance metric: cosine, l2, inner_product",
+                required: false,
+            },
+        ],
+        // eslint-disable-next-line @typescript-eslint/require-await
+        handler: async (args, _context) => {
+            const contentType = args["contentType"] ?? "documents";
+            const dimensions = args["dimensions"] ?? "1536";
+            const distanceMetric = args["distanceMetric"] ?? "cosine";
+            return `# pgVector Setup Guide - ${contentType.charAt(0).toUpperCase() + contentType.slice(1)}
+
+**Configuration:**
+- Content Type: ${contentType}
+- Embedding Dimensions: ${dimensions} (OpenAI ada-002 standard)
+- Distance Metric: ${distanceMetric}
+
+## Setup Steps
+
+### 1. Install pgvector
+
+\`\`\`sql
+CREATE EXTENSION IF NOT EXISTS vector;
+SELECT * FROM pg_extension WHERE extname = 'vector';
+\`\`\`
+
+### 2. Create Table
+
+\`\`\`sql
+CREATE TABLE ${contentType} (
+    id SERIAL PRIMARY KEY,
+    content TEXT NOT NULL,
+    metadata JSONB,
+    embedding vector(${dimensions}),
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+\`\`\`
+
+### 3. Distance Metrics
+
+**Cosine (${distanceMetric === "cosine" ? "✓ Selected" : ""})** - Most common for embeddings:
+\`\`\`sql
+SELECT id, 1 - (embedding <=> query_vector) as similarity
+FROM ${contentType} ORDER BY embedding <=> query_vector LIMIT 10;
+\`\`\`
+
+**L2/Euclidean (${distanceMetric === "l2" ? "✓ Selected" : ""}):**
+\`\`\`sql
+SELECT id, embedding <-> query_vector as distance
+FROM ${contentType} ORDER BY embedding <-> query_vector LIMIT 10;
+\`\`\`
+
+**Inner Product (${distanceMetric === "inner_product" ? "✓ Selected" : ""}):**
+\`\`\`sql
+SELECT id, (embedding <#> query_vector) * -1 as similarity
+FROM ${contentType} ORDER BY embedding <#> query_vector LIMIT 10;
+\`\`\`
+
+### 4. Create Index
+
+**HNSW (Best Quality):**
+\`\`\`sql
+CREATE INDEX ON ${contentType}
+USING hnsw (embedding vector_${distanceMetric}_ops)
+WITH (m = 16, ef_construction = 64);
+\`\`\`
+
+**IVFFlat (Faster Build):**
+\`\`\`sql
+CREATE INDEX ON ${contentType}
+USING ivfflat (embedding vector_${distanceMetric}_ops)
+WITH (lists = 100);
+\`\`\`
+
+### 5. Query Similar Content
+
+Use \`pg_vector_search\`:
+\`\`\`
+pg_vector_search(
+    table_name: "${contentType}",
+    vector_column: "embedding",
+    query_vector: [...],
+    distance_metric: "${distanceMetric}",
+    limit: 10
+)
+\`\`\`
+
+### 6. Performance Tuning
+
+- **Small dataset (<100K):** m=16, ef_construction=64
+- **Medium dataset (100K-1M):** m=32, ef_construction=128
+- **Large dataset (>1M):** m=48, ef_construction=256
+
+Use \`pg_vector_performance\` to benchmark your configuration.
+
+## Available Tools
+
+| Tool | Purpose |
+|------|---------|
+| \`pg_vector_create_extension\` | Enable pgvector extension |
+| \`pg_vector_add_column\` | Add vector column to table |
+| \`pg_vector_search\` | Similarity search with distance metrics |
+| \`pg_vector_create_index\` | Create HNSW or IVFFlat index |
+| \`pg_vector_update\` | Update vector values |
+| \`pg_vector_batch_insert\` | Bulk insert embeddings |
+| \`pg_vector_aggregate\` | Aggregate vector operations |
+| \`pg_vector_distance\` | Calculate distance between vectors |
+| \`pg_vector_nearest\` | Find K nearest neighbors |
+| \`pg_vector_hybrid_search\` | Combine vector + keyword search |
+| \`pg_vector_normalize\` | Normalize vectors |
+| \`pg_vector_performance\` | Benchmark configuration |
+| \`pg_vector_info\` | Get pgvector version and columns |
+| \`pg_vector_drop_index\` | Drop vector index |
+| \`pg_vector_reindex\` | Rebuild vector index |
+
+## Best Practices
+
+1. Normalize embeddings if using inner product
+2. Batch insert embeddings for performance
+3. Use HNSW indexes for production
+4. VACUUM ANALYZE after bulk inserts
+
+**Pro Tip:** pgvector is PostgreSQL's killer AI feature - no other database does vector search this well!`;
+        },
+    };
+}
+//# sourceMappingURL=pgvector.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pgvector.js","sourceRoot":"","sources":["../../../../src/adapters/postgresql/prompts/pgvector.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,MAAM,UAAU,yBAAyB;IACvC,OAAO;QACL,IAAI,EAAE,mBAAmB;QACzB,WAAW,EACT,4GAA4G;QAC9G,SAAS,EAAE;YACT;gBACE,IAAI,EAAE,aAAa;gBACnB,WAAW,EAAE,8CAA8C;gBAC3D,QAAQ,EAAE,KAAK;aAChB;YACD;gBACE,IAAI,EAAE,YAAY;gBAClB,WAAW,EAAE,yDAAyD;gBACtE,QAAQ,EAAE,KAAK;aAChB;YACD;gBACE,IAAI,EAAE,gBAAgB;gBACtB,WAAW,EAAE,4CAA4C;gBACzD,QAAQ,EAAE,KAAK;aAChB;SACF;QACD,4DAA4D;QAC5D,OAAO,EAAE,KAAK,EACZ,IAA4B,EAC5B,QAAwB,EACP,EAAE;YACnB,MAAM,WAAW,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,WAAW,CAAC;YACvD,MAAM,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,MAAM,CAAC;YAChD,MAAM,cAAc,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,QAAQ,CAAC;YAE1D,OAAO,4BAA4B,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;;;kBAGjF,WAAW;0BACH,UAAU;qBACf,cAAc;;;;;;;;;;;;;;eAcpB,WAAW;;;;uBAIH,UAAU;;;;;;;YAOrB,cAAc,KAAK,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE;;;OAGpD,WAAW;;;kBAGA,cAAc,KAAK,IAAI,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE;;;OAGtD,WAAW;;;mBAGC,cAAc,KAAK,eAAe,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE;;;OAGlE,WAAW;;;;;;;kBAOA,WAAW;+BACE,cAAc;;;;;;kBAM3B,WAAW;kCACK,cAAc;;;;;;;;;mBAS7B,WAAW;;;wBAGN,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0GAwCoE,CAAC;QACvG,CAAC;KACF,CAAC;AACJ,CAAC"}

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

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

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

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

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

@@ -0,0 +1,200 @@
+/**
+ * PostGIS Setup Prompt
+ *
+ * Complete guide for setting up geospatial operations with PostGIS.
+ */
+export function createSetupPostgisPrompt() {
+    return {
+        name: "pg_setup_postgis",
+        description: "Complete guide for setting up geospatial operations with PostGIS including spatial types, indexing, and queries.",
+        arguments: [
+            {
+                name: "useCase",
+                description: "Use case: mapping, distance_calc, spatial_analysis, routing",
+                required: false,
+            },
+        ],
+        // eslint-disable-next-line @typescript-eslint/require-await
+        handler: async (args, _context) => {
+            const useCase = args["useCase"] ?? "mapping";
+            let content = `# PostGIS Setup Guide - ${useCase
+                .split("_")
+                .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+                .join(" ")}
+
+## PostGIS Overview
+
+PostGIS provides:
+- 400+ spatial functions
+- Spatial indexing (GiST, BRIN, SP-GiST)
+- Geometry and Geography data types
+- Spatial relationship analysis
+
+## Setup Steps
+
+### 1. Install PostGIS
+
+\`\`\`sql
+CREATE EXTENSION IF NOT EXISTS postgis;
+SELECT PostGIS_Full_Version();
+\`\`\`
+
+### 2. Spatial Data Types
+
+**Geometry (Planar):** For local/regional mapping, uses projected coordinates
+**Geography (Spherical):** For global mapping, uses lat/lon (WGS84)
+
+**For ${useCase}:** Use ${useCase === "mapping" || useCase === "routing" ? "Geography for global mapping" : "Geometry for local analysis"}.
+
+### 3. Create Spatial Table
+`;
+            if (useCase === "mapping") {
+                content += `
+\`\`\`sql
+CREATE TABLE locations (
+    id SERIAL PRIMARY KEY,
+    name VARCHAR(255) NOT NULL,
+    description TEXT,
+    location GEOGRAPHY(POINT, 4326),  -- WGS84 (GPS)
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+INSERT INTO locations (name, location)
+VALUES ('San Francisco', ST_GeographyFromText('POINT(-122.4194 37.7749)'));
+\`\`\`
+`;
+            }
+            else if (useCase === "distance_calc") {
+                content += `
+\`\`\`sql
+CREATE TABLE points_of_interest (
+    id SERIAL PRIMARY KEY,
+    name VARCHAR(255),
+    category VARCHAR(50),
+    location GEOGRAPHY(POINT, 4326)
+);
+
+-- Find nearest POIs
+SELECT name,
+    ST_Distance(location, ST_GeographyFromText('POINT(-122.4194 37.7749)')) / 1000 as distance_km
+FROM points_of_interest
+ORDER BY location <-> ST_GeographyFromText('POINT(-122.4194 37.7749)')
+LIMIT 10;
+\`\`\`
+`;
+            }
+            else if (useCase === "spatial_analysis") {
+                content += `
+\`\`\`sql
+CREATE TABLE regions (
+    id SERIAL PRIMARY KEY,
+    name VARCHAR(255),
+    boundary GEOGRAPHY(POLYGON, 4326),
+    properties JSONB
+);
+
+-- Check if point is within region
+SELECT r.name FROM regions r
+WHERE ST_Contains(r.boundary::geometry,
+    ST_GeographyFromText('POINT(-122.4194 37.7749)')::geometry);
+\`\`\`
+`;
+            }
+            else {
+                content += `
+\`\`\`sql
+CREATE TABLE roads (
+    id SERIAL PRIMARY KEY,
+    name VARCHAR(255),
+    road_type VARCHAR(50),
+    geometry GEOGRAPHY(LINESTRING, 4326),
+    length_meters FLOAT
+);
+
+-- Find roads within 1km
+SELECT name, road_type FROM roads
+WHERE ST_DWithin(geometry,
+    ST_GeographyFromText('POINT(-122.4194 37.7749)'), 1000);
+\`\`\`
+`;
+            }
+            content += `
+### 4. Create Spatial Index
+
+\`\`\`sql
+CREATE INDEX idx_locations_geog ON locations USING GIST (location);
+\`\`\`
+
+### 5. Common Spatial Queries
+
+**Distance Queries:**
+Use \`pg_geo_distance\`:
+\`\`\`
+pg_geo_distance(
+    table_name: "locations",
+    geometry_column: "location",
+    reference_point: "POINT(-122.4194 37.7749)",
+    max_distance: 10.0,
+    distance_unit: "kilometers"
+)
+\`\`\`
+
+**Containment Queries:**
+Use \`pg_geo_within\` to find points within a polygon.
+
+**Buffer Operations:**
+Use \`pg_geo_buffer\` to create buffer zones.
+
+### 6. GeoJSON Output
+
+\`\`\`sql
+SELECT jsonb_build_object(
+    'type', 'Feature',
+    'geometry', ST_AsGeoJSON(location)::jsonb,
+    'properties', jsonb_build_object('name', name)
+) as geojson
+FROM locations;
+\`\`\`
+
+## Available Tools
+
+| Tool | Purpose |
+|------|---------|
+| \`pg_postgis_create_extension\` | Enable PostGIS extension |
+| \`pg_geometry_column\` | Add geometry/geography column |
+| \`pg_spatial_index\` | Create spatial GiST index |
+| \`pg_distance\` | Calculate distance between points |
+| \`pg_buffer\` | Create buffer around geometry |
+| \`pg_intersection\` | Find intersection of geometries |
+| \`pg_within\` | Check if geometry is within another |
+| \`pg_contains\` | Check if geometry contains another |
+| \`pg_bounding_box\` | Get bounding box of geometry |
+| \`pg_geocode\` | Geocode addresses (if geocoder installed) |
+| \`pg_geometry_buffer\` | Buffer operations on table data |
+| \`pg_geo_cluster\` | Cluster spatial data |
+| \`pg_geo_index_optimize\` | Analyze spatial index performance |
+| \`pg_nearest_neighbor\` | Find K nearest neighbors |
+| \`pg_spatial_join\` | Join tables on spatial relationship |
+| \`pg_postgis_info\` | Get PostGIS version and capabilities |
+
+## Best Practices
+
+1. **Always use spatial indexes** - 100x+ performance improvement
+2. **Choose appropriate SRID** - 4326 for global, local SRID for regional
+3. **Use geography for distance** - More accurate than geometry for Earth
+4. **Validate geometries** - Use ST_IsValid()
+5. **VACUUM ANALYZE regularly**
+
+## Common Pitfalls
+
+- ❌ Mixing geometry and geography without casting
+- ❌ Not using spatial indexes for large datasets
+- ❌ Using wrong SRID for coordinate system
+- ❌ Calculating area/distance on lat/lon without geography type
+
+**Pro Tip:** PostGIS is PostgreSQL's GIS superpower - it's the industry standard for spatial databases!`;
+            return content;
+        },
+    };
+}
+//# sourceMappingURL=postgis.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"postgis.js","sourceRoot":"","sources":["../../../../src/adapters/postgresql/prompts/postgis.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,MAAM,UAAU,wBAAwB;IACtC,OAAO;QACL,IAAI,EAAE,kBAAkB;QACxB,WAAW,EACT,kHAAkH;QACpH,SAAS,EAAE;YACT;gBACE,IAAI,EAAE,SAAS;gBACf,WAAW,EACT,6DAA6D;gBAC/D,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,SAAS,CAAC;YAE7C,IAAI,OAAO,GAAG,2BAA2B,OAAO;iBAC7C,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;;;;;;;;;;;;;;;;;;;;;;;;QAwBV,OAAO,WAAW,OAAO,KAAK,SAAS,IAAI,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,8BAA8B,CAAC,CAAC,CAAC,6BAA6B;;;CAGxI,CAAC;YAEI,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;gBAC1B,OAAO,IAAI;;;;;;;;;;;;;CAalB,CAAC;YACI,CAAC;iBAAM,IAAI,OAAO,KAAK,eAAe,EAAE,CAAC;gBACvC,OAAO,IAAI;;;;;;;;;;;;;;;;CAgBlB,CAAC;YACI,CAAC;iBAAM,IAAI,OAAO,KAAK,kBAAkB,EAAE,CAAC;gBAC1C,OAAO,IAAI;;;;;;;;;;;;;;CAclB,CAAC;YACI,CAAC;iBAAM,CAAC;gBACN,OAAO,IAAI;;;;;;;;;;;;;;;CAelB,CAAC;YACI,CAAC;YAED,OAAO,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wGA0EuF,CAAC;YAEnG,OAAO,OAAO,CAAC;QACjB,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/adapters/postgresql/resources/activity.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Activity Resource
+ *
+ * Current database connections and running queries with blocking detection.
+ */
+import type { PostgresAdapter } from "../PostgresAdapter.js";
+import type { ResourceDefinition } from "../../../types/index.js";
+export declare function createActivityResource(adapter: PostgresAdapter): ResourceDefinition;
+//# sourceMappingURL=activity.d.ts.map