opencode-skills-collection 4.0.0 → 4.0.1

package/bundled-skills/postgres-readonly-queries/scripts/query.py

@@ -0,0 +1,262 @@
+#!/usr/bin/env python3
+"""
+Read-only PostgreSQL query executor.
+Connects to configured databases and executes SELECT queries only.
+"""
+
+import json
+import os
+import re
+import stat
+import sys
+import argparse
+from pathlib import Path
+from typing import Optional
+
+try:
+    import psycopg2
+except ImportError:
+    print("Error: psycopg2 not installed. Run: pip install psycopg2-binary")
+    sys.exit(1)
+
+# Constants
+SCRIPT_DIR = Path(__file__).parent.parent
+CONFIG_LOCATIONS = [
+    SCRIPT_DIR / "connections.json",
+    Path.home() / ".config" / "claude" / "postgres-connections.json",
+]
+MAX_ROWS = 10000
+MAX_COLUMN_WIDTH = 100
+QUERY_TIMEOUT_MS = 30000
+CONNECTION_TIMEOUT_SEC = 10
+NULL_DISPLAY = "<NULL>"
+
+
+def is_read_only(query: str) -> bool:
+    """Basic client-side check. Primary protection is readonly=True session."""
+    query_upper = query.upper().strip()
+    safe_starts = ('SELECT', 'SHOW', 'DESCRIBE', 'EXPLAIN', 'WITH', '\\D')
+    return any(query_upper.startswith(cmd) for cmd in safe_starts)
+
+
+def validate_single_statement(query: str) -> bool:
+    """Check query contains only one statement."""
+    # Remove trailing semicolon and whitespace, then check for remaining semicolons
+    clean = query.rstrip().rstrip(';')
+    return ';' not in clean
+
+
+def validate_config_permissions(path: Path) -> None:
+    """Warn if config file has insecure permissions (Unix only)."""
+    if os.name != 'nt':  # Skip on Windows
+        mode = path.stat().st_mode
+        if bool(mode & stat.S_IRWXG) or bool(mode & stat.S_IRWXO):
+            print(f"WARNING: {path} has insecure permissions!")
+            print(f"Config contains credentials. Run: chmod 600 {path}")
+
+
+def validate_db_config(db: dict) -> None:
+    """Validate required fields exist in database config."""
+    required = ['name', 'host', 'database', 'user', 'password']
+    missing = [f for f in required if f not in db]
+    if missing:
+        print(f"Error: Database config missing fields: {', '.join(missing)}")
+        sys.exit(1)
+
+
+def find_config() -> Optional[Path]:
+    """Find config file in supported locations."""
+    for path in CONFIG_LOCATIONS:
+        if path.exists():
+            return path
+    return None
+
+
+def load_config(config_path: Optional[Path] = None) -> dict:
+    """Load database connections from JSON config."""
+    path = config_path or find_config()
+    if not path:
+        print("Config not found. Searched:")
+        for loc in CONFIG_LOCATIONS:
+            print(f"  - {loc}")
+        print("\nCreate connections.json with format:")
+        print(json.dumps({
+            "databases": [{
+                "name": "mydb",
+                "description": "Description of database contents",
+                "host": "localhost",
+                "port": 5432,
+                "database": "mydb",
+                "user": "user",
+                "password": "password",
+                "sslmode": "prefer"
+            }]
+        }, indent=2))
+        sys.exit(1)
+
+    validate_config_permissions(path)
+
+    with open(path) as f:
+        return json.load(f)
+
+
+def list_databases(config: dict) -> None:
+    """List all configured databases."""
+    print("Configured databases:\n")
+    for db in config.get("databases", []):
+        validate_db_config(db)
+        print(f"  [{db['name']}]")
+        print(f"    Host: {db['host']}:{db.get('port', 5432)}")
+        print(f"    Database: {db['database']}")
+        print(f"    Description: {db.get('description', 'No description')}")
+        print()
+
+
+def execute_query(db_config: dict, query: str, limit: Optional[int] = None) -> None:
+    """Execute a read-only query against the specified database."""
+    if not is_read_only(query):
+        print("Error: Only read-only queries (SELECT, SHOW, EXPLAIN) are allowed.")
+        sys.exit(1)
+
+    if not validate_single_statement(query):
+        print("Error: Multiple statements not allowed. Execute queries separately.")
+        sys.exit(1)
+
+    # Apply limit using regex to avoid false positives from string content
+    if limit and not re.search(r'\bLIMIT\s+\d+', query, re.IGNORECASE):
+        query = f"{query.rstrip(';')} LIMIT {limit}"
+
+    conn = None
+    try:
+        conn = psycopg2.connect(
+            host=db_config['host'],
+            port=db_config.get('port', 5432),
+            database=db_config['database'],
+            user=db_config['user'],
+            password=db_config['password'],
+            sslmode=db_config.get('sslmode', 'prefer'),
+            connect_timeout=CONNECTION_TIMEOUT_SEC,
+            options=f'-c statement_timeout={QUERY_TIMEOUT_MS}'
+        )
+        # Primary safety: readonly session prevents any write operations
+        conn.set_session(readonly=True, autocommit=True)
+
+        with conn.cursor() as cur:
+            cur.execute(query)
+            if cur.description:
+                columns = [desc[0] for desc in cur.description]
+                rows = cur.fetchmany(MAX_ROWS)
+                truncated = len(rows) == MAX_ROWS
+
+                # Calculate column widths with cap
+                widths = [min(len(col), MAX_COLUMN_WIDTH) for col in columns]
+                for row in rows:
+                    for i, val in enumerate(row):
+                        val_str = str(val) if val is not None else NULL_DISPLAY
+                        widths[i] = min(max(widths[i], len(val_str)), MAX_COLUMN_WIDTH)
+
+                # Print header
+                header = " | ".join(col[:MAX_COLUMN_WIDTH].ljust(widths[i]) for i, col in enumerate(columns))
+                print(header)
+                print("-" * len(header))
+
+                # Print rows
+                for row in rows:
+                    cells = []
+                    for i, val in enumerate(row):
+                        val_str = str(val) if val is not None else NULL_DISPLAY
+                        if len(val_str) > MAX_COLUMN_WIDTH:
+                            val_str = val_str[:MAX_COLUMN_WIDTH-3] + "..."
+                        cells.append(val_str.ljust(widths[i]))
+                    print(" | ".join(cells))
+
+                msg = f"\n({len(rows)} rows)"
+                if truncated:
+                    msg += f" [truncated at {MAX_ROWS}]"
+                print(msg)
+            else:
+                print("Query executed (no result set returned)")
+
+    except psycopg2.Error as e:
+        error_msg = str(e)
+        # Sanitize to avoid leaking credentials
+        if 'password' in error_msg.lower() or 'authentication' in error_msg.lower():
+            error_msg = "Authentication failed. Check credentials in connections.json"
+        print(f"Database error: {error_msg}")
+        sys.exit(1)
+    finally:
+        if conn:
+            conn.close()
+
+
+def find_database(config: dict, name: str) -> dict:
+    """Find database config by name (case-insensitive)."""
+    for db in config.get("databases", []):
+        if db.get('name', '').lower() == name.lower():
+            validate_db_config(db)
+            return db
+    available = [db.get('name', 'unnamed') for db in config.get("databases", [])]
+    print(f"Database '{name}' not found.")
+    print(f"Available: {', '.join(available)}")
+    sys.exit(1)
+
+
+def main() -> None:
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description="Execute read-only PostgreSQL queries",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s --list
+  %(prog)s --db mydb --tables
+  %(prog)s --db mydb --query "SELECT * FROM users" --limit 100
+        """
+    )
+    parser.add_argument("--config", "-c", type=Path, help="Path to config JSON")
+    parser.add_argument("--db", "-d", help="Database name to query")
+    parser.add_argument("--query", "-q", help="SQL query to execute")
+    parser.add_argument("--limit", "-l", type=int, help="Limit rows returned")
+    parser.add_argument("--list", action="store_true", help="List configured databases")
+    parser.add_argument("--schema", "-s", action="store_true", help="Show database schema")
+    parser.add_argument("--tables", "-t", action="store_true", help="List tables")
+
+    args = parser.parse_args()
+    config = load_config(args.config)
+
+    if args.list:
+        list_databases(config)
+        return
+
+    if not args.db:
+        print("Error: --db required. Use --list to see available databases.")
+        sys.exit(1)
+
+    db_config = find_database(config, args.db)
+
+    if args.tables:
+        query = """
+            SELECT table_schema, table_name, table_type
+            FROM information_schema.tables
+            WHERE table_schema NOT IN ('pg_catalog', 'information_schema')
+            ORDER BY table_schema, table_name
+        """
+        execute_query(db_config, query, args.limit)
+    elif args.schema:
+        query = """
+            SELECT c.table_schema, c.table_name, c.column_name, c.data_type, c.is_nullable
+            FROM information_schema.columns c
+            JOIN information_schema.tables t ON c.table_name = t.table_name AND c.table_schema = t.table_schema
+            WHERE c.table_schema NOT IN ('pg_catalog', 'information_schema')
+            ORDER BY c.table_schema, c.table_name, c.ordinal_position
+        """
+        execute_query(db_config, query, args.limit)
+    elif args.query:
+        execute_query(db_config, args.query, args.limit)
+    else:
+        print("Error: --query, --tables, or --schema required")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/bundled-skills/pptx-deck-creation/SKILL.md

@@ -0,0 +1,275 @@
+---
+name: pptx-deck-creation
+description: "Create editable, production-ready PPTX decks with narrative planning, explicit layout specs, asset guidance, and quality checks."
+category: office-productivity
+risk: critical
+source: community
+source_repo: kimtth/agent-pptify-kit
+source_type: community
+date_added: "2026-07-14"
+author: kimtth
+tags: [powerpoint, pptx, presentation, slide-design, document-generation]
+tools: [claude, cursor, gemini, codex, antigravity]
+license: "MIT"
+license_source: "https://github.com/kimtth/agent-pptify-kit/blob/main/LICENSE"
+---
+
+# PPTX Deck Creation
+
+## Overview
+
+Create an editable PowerPoint deck from a clear narrative, source evidence, and
+explicit layout decisions. Keep the deck specification and its native
+PowerPoint objects as the source of truth. Images may support a slide, but they
+must not replace editable titles, labels, data, tables, or diagrams.
+
+Use the bundled references for design-profile selection, reference-deck
+analysis, visual-asset decisions, and final quality checks. The skill does not
+ship a general-purpose renderer or bundled runtime scripts.
+
+## Scope Boundary
+
+Use this skill as the primary workflow for creating a new, editable PPTX deck.
+It owns the path from a deck brief through narrative planning, a
+coordinate-explicit specification, task-specific PPTX generation, and final
+quality assurance. Do not redirect a net-new deck to another skill merely
+because the requested deliverable is a `.pptx` file.
+
+Use `@pptx-official` when work starts with an existing PPTX and requires
+package-level operations: raw OOXML editing, template duplication and text
+replacement, speaker notes, comments, animations, or other structural changes
+to that file. It may support a build when those operations are necessary, but
+it is not the default workflow for a net-new deck authored here.
+
+## When to Use This Skill
+
+* Use when a user asks to create a new editable PowerPoint or PPTX deck
+* Use as the default workflow when a new deck needs to be delivered as a `.pptx` file
+* Use when a deck needs a narrative framework, a design direction, and final coordinates
+* Use when analyzing a reference PPTX without copying its binary content
+* Use when reviewing a generated PPTX for layout, package, or accessibility defects
+
+## How It Works
+
+### Step 1: Understand the requested deck
+
+Collect the audience, decision or purpose, language, slide count, source
+material, brand requirements, and delivery format. Ask the user to select a
+narrative framework if they have not already done so. Do not select one on the
+user's behalf.
+
+Use one of these framework spines, or a user-defined alternative:
+
+| Framework | Use case |
+|---|---|
+| `mckinsey` | Executive proposals and strategic recommendations |
+| `scqa` | Situation, complication, question, answer narratives |
+| `pyramid` | Main answer followed by supporting arguments |
+| `mece` | Issue decomposition and workstream synthesis |
+| `action-title` | Executive communications with conclusion-led titles |
+| `assertion-evidence` | Technical or research presentations |
+| `exec-summary-first` | Board and leadership briefings |
+| `custom` | User-defined structure or organization playbook |
+
+Record the resolved framework, its source, title rules, slide sequence, and
+any approved assumptions in the deck summary.
+
+### Step 2: Establish source and design context
+
+Give each factual source a stable ID. Record a source reference for every
+metric, chart value, quotation, and factual claim that appears in the deck.
+Summarize source material into one message per slide rather than pasting long
+documents into the specification.
+
+For a reference presentation, inspect it read-only. Extract palette, font,
+slide-size, template, layout-flow, and topic-sequence signals. Re-author target
+slides with their own explicit coordinates. Do not copy, mutate, or use the
+source PPTX as a template for generated content.
+
+Select a documented design profile from
+[design profiles](references/design-profiles.md). Use the user's named profile
+first. Use a reference deck when one is available. Otherwise, use Fluent UI
+Design Token Guidance by default, use Primer Primitives for GitHub-focused
+technical decks, and use a broader style catalog only when the user requests
+multiple visual directions. Record the selected profile, source URL, license,
+palette, typography, spacing, and signature visual treatment in
+`summary.design_context`.
+
+### Step 3: Plan the story and visual structure
+
+Create one defensible message per slide. Use conclusion-led slide titles when
+the selected framework calls for them. Keep the storyline mutually exclusive
+and collectively exhaustive where appropriate. Include concrete numbers, dates,
+owners, and sources only when supported by the evidence.
+
+Every normal content slide needs a visible, style-derived structure such as an
+accent band, card shell, divider, grid, diagram primitive, or image treatment.
+Avoid plain title-and-bullets slides, default theme colors, and Calibri-only
+output unless the user explicitly requests that treatment.
+
+### Step 4: Author a coordinate-explicit specification
+
+Create a JSON object with `summary` and `slides`. Every generated slide needs
+an `id`, `title`, and complete `layout_tree`. Use final inch-based bounding
+boxes, z-order, colors, font sizes, and grouping. Do not rely on a renderer to
+make layout decisions.
+
+Include this production metadata before building:
+
+```json
+{
+  "summary": {
+    "layout_policy": {
+      "safe_margin": 0.5,
+      "content_bottom": 6.7,
+      "footer_top": 6.85,
+      "minimum_gap": 0.12
+    },
+    "accessibility": {
+      "language": "en-US",
+      "presentation_title": "Deck title"
+    }
+  }
+}
+```
+
+Keep content inside the safe margin and above the footer rail. Use native
+`text`, `shape`, `line`, `table`, and `image` objects. Add alt text to
+meaningful images and a reading order for each production slide. Use images as
+supporting visuals only; recreate essential labels, legend entries, process
+steps, and data values as editable objects.
+
+Use the following object constraints:
+
+* Keep content text at 9 pt or larger; prefer 10 to 12 pt for body copy
+* Keep every child object inside its parent group bounding box
+* Keep table column widths equal to the table width and split dense tables across slides
+* Keep normal content objects within slide bounds; only decorative full-bleed elements may cross an edge
+* Keep images behind overlapping text and preserve their aspect ratio
+* Store `source_ref` with source ID, locator, claim type, and verification status for sourced claims
+
+### Step 5: Create the PPTX deck when requested
+
+Own net-new PPTX creation in this workflow. When a PPTX file is required,
+create a small task-specific builder with the user's approved environment. Start
+slides from a blank layout and create native objects from the final bounding
+boxes. Enable word wrap, disable automatic text resizing, set text insets and
+alignment explicitly, and reject zero or negative bounding boxes before
+building.
+
+Save the authored specification, PPTX, build manifest, audit records, and
+source manifest together. Do not add a large shared renderer or copy source
+presentation content. Use `@pptx-official` only when the requested result also
+requires an existing-file or OOXML workflow.
+
+### Step 6: Validate and repair
+
+Apply the [manual audit checklist](references/audit-checklist.md) before and
+after building. Check collisions, text capacity, font sizes, safe margins,
+group containment, table fit, object bounds, design context, and native
+editability. Reopen the PPTX to verify slide count, package structure, hidden
+slides, actual geometry, language, image alt text, reading order, and table
+headers.
+
+Inspect rendered previews when a compatible renderer is available. Check
+clipping, font fallback, contrast, image crops, and visual hierarchy. Repair
+the specification or the task-specific builder, rebuild, and repeat the audit
+until all deterministic failures are resolved. Report any remaining exception
+with the slide ID, object ID, reason, owner, and review date.
+
+## Reference-Deck Analysis
+
+The skill provides a read-only analysis contract, not packaged code. For a
+specific task, use `python-pptx` and the Office Open XML package to inspect a
+presentation. Produce only the context needed for the task:
+
+* Compact prompt context with slide count, styles, brands, template, and layout
+* Full extraction with `layout_tree`, summary metrics, and render-aware elements
+* Folder-level diagnostics with one result per deck and a manifest
+* Style-master analysis with colors, fonts, layout usage, and flow patterns
+
+Use [reference-deck analysis recipes](references/reference-deck-analysis.md)
+and [Python guidance](references/python-snippets.md) as static implementation
+references. Keep all extraction read-only.
+
+## Visual Assets
+
+Use [visual asset guidelines](references/visual-asset-adapters.md) when an icon,
+image, SVG, or user-managed infographic is needed. Confirm image licensing
+before placing it. Record asset provenance, local path, and alt text. Never ask
+users to provide secrets in chat, and never use a placeholder when acquisition
+fails.
+
+When a provider, output path, or other required setting is missing, ask for the
+non-secret information before generating an infographic. If no configured
+provider is available, omit the asset and continue with editable native slide
+objects.
+
+Before any external generation call, disclose the provider and model, what
+prompt or source material will leave the machine, the likely cost, and the
+output path. Obtain explicit confirmation unless the user already authorized
+that exact operation. Never overwrite an existing output without separate
+confirmation.
+
+## Examples
+
+### Example 1: Executive recommendation deck
+
+A user asks for a 10-slide leadership deck based on a project brief. Confirm
+the audience, choose `exec-summary-first`, summarize the brief into one claim
+per slide, and create coordinate-explicit content cards with a documented
+Fluent UI design context. Add source references for each brief-derived metric,
+then build and audit the requested PPTX.
+
+### Example 2: Reference-deck-informed proposal
+
+A user supplies a prior PPTX and asks for a new proposal in a similar visual
+language. Extract only the existing deck's palette, typography, layout rhythm,
+and template usage. Use those signals to design a new outline and native layout
+tree. Do not duplicate slides, copy the deck's binary parts, or present the
+reference deck as the new deliverable.
+
+## Best Practices
+
+* Keep the business framework and source lineage visible in the deck summary
+* Make each slide title convey the slide's conclusion or narrative role
+* Use source evidence for charts and dashboard-like exhibits
+* Build meaningful content from native editable PowerPoint objects
+* Add a deliberate visual structure to every normal content slide
+* Rebuild and inspect previews after repairing layout or text issues
+
+## Limitations
+
+* This skill does not replace a user-provided brand guide, legal asset review, or expert accessibility review
+* It does not include a general renderer, a bundled extraction module, or credentials for external providers
+* It does not own raw OOXML editing, template duplication, or other mutations of an existing PPTX package
+* Stop and ask for clarification when the audience, source evidence, brand requirements, or required output path is missing
+
+## Security and Safety Notes
+
+* Keep reference-deck analysis read-only and never overwrite the source deck
+* Request confirmation before any task-specific build or repair overwrites an existing output file
+* Use user-managed providers only and keep credentials outside chat and skill content
+* Omit unlicensed or license-ambiguous visual assets instead of substituting placeholders
+
+## Common Pitfalls
+
+### Problem: A slide has more copy than its bounding box can hold
+
+Shorten the copy, enlarge the bounding box, or split the content across slides.
+Do not solve the issue by reducing meaningful content below 9 pt.
+
+### Problem: The deck resembles an unstyled default PowerPoint file
+
+Select and record a design profile, then add explicit background, typography,
+accent, card, divider, or grid primitives to the layout tree.
+
+### Problem: A reference deck is used as a source file for the output
+
+Treat the reference deck as read-only context. Re-author the target deck with
+its own slide specification and native editable content.
+
+## Related Skills
+
+* `@pptx-official` - Use for existing PPTX, OOXML, and template-mutation workflows, not default net-new deck creation
+* `@python-pptx-generator` - Use for focused Python PPTX generation patterns