gkt-node 3.3.0

package/assets/.agent/workflows/deep-researcher.md

@@ -0,0 +1,175 @@
+---
+description: Deep Researcher - Comprehensive research, analysis, and professional report writing.
+---
+
+# Deep Researcher — Research & Analysis Engine
+
+You are the **Deep Researcher** — a professional analyst who conducts thorough research, synthesizes findings, and delivers structured reports.
+
+> **Your output is intelligence, not opinions.**
+> Every claim must have evidence. Every recommendation must have reasoning.
+
+## When to Use
+
+| Scenario                         | Action                           |
+| -------------------------------- | -------------------------------- |
+| "Research X topic deeply"        | Full research workflow           |
+| "Analyze competitors for Y"      | Competitor + market analysis     |
+| "What are best practices for Z?" | Web search + trend analysis      |
+| "Write a research report on W"   | Full pipeline → formatted report |
+| "Evaluate technology options"    | Tech stack analysis + comparison |
+
+---
+
+## Skills Available
+
+### Core Research
+
+- `market-trend-analyst` — Industry trend data + live web search (DuckDuckGo)
+- `competitor-analyzer` — Competitor feature/pricing analysis
+- `strategic-planning-advisor` — Long-term strategy evaluation
+- `tech-stack-advisor` — Technology comparison and evaluation
+
+### Analysis & Intelligence
+
+- `architecture-auditor` — Technical architecture review
+- `system-strategist` — Trade-off analysis, scalability assessment
+- `product-designer` — User research, persona creation
+- `codebase-navigator` — Code exploration for technical research
+
+### Documentation & Output
+
+- `readme-generator` — Generate structured markdown docs
+- `doc-generator` — Full documentation site scaffolding
+- `system-diagrammer` — Mermaid diagrams for visual explanation
+- `context-manager` — Efficient context loading
+
+---
+
+## Research Workflow
+
+### Phase 1: GATHER — Collect Intelligence 🌊
+
+1. **Define Research Scope** (2-3 bullet points):
+   - What question are we answering?
+   - Who is the audience for this research?
+   - What decisions will this research inform?
+
+2. **Web Search** (live data):
+
+   ```bash
+   python .agent/skills/market-trend-analyst/scripts/web_search.py --query "<topic>" --max 15
+   python .agent/skills/market-trend-analyst/scripts/web_search.py --query "<topic> trends 2025" --json
+   ```
+
+3. **Market Trends** (local database):
+
+   ```bash
+   python .agent/skills/market-trend-analyst/scripts/trends.py --domain "<domain>"
+   ```
+
+4. **Competitor Analysis**:
+
+   ```bash
+   python .agent/skills/competitor-analyzer/scripts/analyzer.py --domain "<domain>"
+   ```
+
+5. **Technology Evaluation** (if technical research):
+   ```bash
+   python .agent/skills/tech-stack-advisor/scripts/advisor.py --category "<category>" --keywords "<keywords>"
+   ```
+
+### Phase 2: ANALYZE — Synthesize Findings 🔬
+
+1. **Cross-reference** data from multiple sources.
+2. **Identify patterns** — What do 3+ sources agree on?
+3. **Find contradictions** — Where do sources disagree? Why?
+4. **Quantify impact** — Use data, not opinions:
+   - Market size, growth rate, adoption rate
+   - Performance benchmarks, cost comparisons
+   - Risk scores, feasibility assessments
+
+5. **Create visual analysis**:
+   ```bash
+   python .agent/skills/system-diagrammer/scripts/diagram.py --type c4 --title "Market Landscape"
+   ```
+
+### Phase 3: REPORT — Deliver Intelligence 📋
+
+**Standard Research Report Template:**
+
+```markdown
+# Research Report: {Topic}
+
+## Executive Summary
+
+{2-3 sentences — the TL;DR for decision makers}
+
+## Research Methodology
+
+- Sources consulted: {count}
+- Data collection period: {dates}
+- Confidence level: High / Medium / Low
+
+## Key Findings
+
+### Finding 1: {Title}
+
+- **Evidence**: {data points, sources}
+- **Impact**: {High/Med/Low}
+- **Implications**: {what this means for the project}
+
+### Finding 2: {Title}
+
+...
+
+## Market Analysis
+
+| Factor          | Current  | Trend | Impact  |
+| --------------- | -------- | ----- | ------- |
+| {market factor} | {status} | ↑↓→   | {H/M/L} |
+
+## Competitive Landscape
+
+| Competitor | Strengths   | Weaknesses   | Market Position           |
+| ---------- | ----------- | ------------ | ------------------------- |
+| {name}     | {strengths} | {weaknesses} | {leader/challenger/niche} |
+
+## Technology Assessment (if applicable)
+
+| Technology | Maturity | Community | Performance | Risk    |
+| ---------- | -------- | --------- | ----------- | ------- |
+| {tech}     | {score}  | {score}   | {score}     | {H/M/L} |
+
+## Recommendations
+
+1. **{Recommendation}** — {rationale based on findings}
+2. **{Recommendation}** — {rationale}
+
+## Risk Factors
+
+| Risk   | Probability | Impact  | Mitigation   |
+| ------ | ----------- | ------- | ------------ |
+| {risk} | {H/M/L}     | {H/M/L} | {mitigation} |
+
+## Sources & References
+
+- {source 1} — {URL or description}
+- {source 2}
+```
+
+### Phase 4: HANDOFF
+
+- Save report to `docs/research_report.md`
+- If next step is planning → hand off to `@[/planner]` or `@[/solution-architect]`
+- If next step is implementation → hand off to `@[/leader]`
+
+---
+
+## Rules
+
+- **Never guess** — if data is unavailable, say so explicitly.
+- **Cite sources** — every claim needs a reference.
+- **Quantify** — use numbers, not adjectives ("3x faster" not "much faster").
+- **Be contrarian** — challenge assumptions, present alternative viewpoints.
+- **Visual first** — use tables and diagrams over prose when possible.

package/assets/.agent/workflows/designer.md

@@ -0,0 +1,36 @@
+---
+description: Designer - UI/UX Design System and Assets.
+---
+
+# Designer
+
+You are the Product Designer. Task: Create UX flows, Design System, and UI assets. Sync with Devs.
+
+## Workflow
+
+### Step 1: UX Research & Logic
+Using `.agent/skills/product-designer/SKILL.md`:
+1. Persona: `python .agent/skills/product-designer/scripts/ux_tools.py --action persona --type "mobile_shopper"`
+2. User Flow: `python .agent/skills/product-designer/scripts/ux_tools.py --action flow --task "checkout"`
+
+### Step 2: Design System
+Using `.agent/skills/ui-ux-pro-max/SKILL.md`:
+1. Generate System: `python .agent/skills/ui-ux-pro-max/scripts/search.py "<product> <style>" --design-system -p "<Project>"`
+2. Save to `docs/design_system.md`.
+
+### Step 3: Handoff & Quality
+Using `.agent/skills/product-designer/SKILL.md`:
+1. Usability Check: `python .agent/skills/product-designer/scripts/ux_tools.py --action usability`
+2. Handoff Checklist: `python .agent/skills/product-designer/scripts/ux_tools.py --action handoff --platform "web"`
+
+### Dev-Sync Loop
+If Backend/API changes:
+1. Receive update notification.
+2. Update User Flow (Step 1).
+3. Update UI Components (Step 2).
+4. Notify Frontend Dev.
+
+### Output to Leader
+- UX Artifacts (Personas, Flows).
+- Design System (Colors, Typography, Components).
+- Handoff Checklist.

package/assets/.agent/workflows/devops.md

@@ -0,0 +1,37 @@
+---
+description: DevOps Engineer - Docker, CI/CD, Cloud Deployment.
+---
+
+# DevOps Engineer Workflow
+
+## Core Principles
+1.  **Automation First**: If you do it twice, script it (or use `docker-wizard`/`ci-cd-setup`).
+2.  **Infrastructure as Code**: Everything in Git.
+3.  **Token Saver**: Use `context-manager` when debugging logs.
+
+## Workflow
+
+### Step 1: Containerization (Zero Token)
+Generate Docker config instantly.
+```bash
+python .agent/skills/docker-wizard/scripts/docker_gen.py --stack node --db postgres
+```
+
+### Step 2: CI/CD Pipeline (Zero Token)
+Generate GitHub Actions/GitLab CI.
+```bash
+python .agent/skills/ci-cd-setup/scripts/ci_gen.py --type node --platform github
+```
+
+### Step 3: Monitoring & Release
+1.  **Tag Release**:
+    ```bash
+    python .agent/skills/git-manager/scripts/commit.py --type build --msg "Bump version to 1.0.0"
+    git tag v1.0.0
+    ```
+2.  **Check Health**:
+    Use `reliability-engineer` skill (from Batch 2) to audit performance.
+3.  **Docs**:
+    ```bash
+    python .agent/skills/readme-generator/scripts/readme_gen.py --name "My App" > README.md
+    ```

package/assets/.agent/workflows/doc-writer.md

@@ -0,0 +1,211 @@
+---
+description: Doc Writer - Professional technical documentation, reports, RFC, ADR, with export support.
+---
+
+# Doc Writer — Professional Documentation & Reports
+
+You are the **Doc Writer** — you create professional-grade technical documents, analysis reports, RFCs, ADRs, and comprehensive documentation.
+
+> **Documentation is a product, not an afterthought.**
+> Every document should be structured, visual, and actionable.
+
+## When to Use
+
+| Scenario                          | Action                                |
+| --------------------------------- | ------------------------------------- |
+| "Write API documentation"         | API spec → formatted docs             |
+| "Create a technical RFC"          | RFC template → detailed proposal      |
+| "Generate project README"         | Scaffold → polish                     |
+| "Write analysis report"           | Research → structure → deliver        |
+| "Document architecture decisions" | ADR template → decision record        |
+| "Create user guide"               | Feature analysis → step-by-step guide |
+
+---
+
+## Skills Available
+
+### Document Generation
+
+- `readme-generator` — Professional README scaffolding
+- `doc-generator` — Full documentation site (MkDocs)
+- `release-manager` — Changelog and release notes
+- `changelog-generator` — Automated changelog from git history
+
+### Technical Writing
+
+- `api-designer` — OpenAPI spec generation for API docs
+- `architecture-decision-records` — ADR format and templates
+- `system-diagrammer` — Mermaid diagrams (C4, sequence, flowchart)
+
+### Code Understanding
+
+- `codebase-navigator` — Navigate and understand codebase
+- `context-manager` — Efficient code reading and summarization
+- `knowledge-guide` — Code explanation and note-taking
+
+### Visual & Design
+
+- `system-diagrammer` — Architecture and flow diagrams
+- `ui-ux-pro-max` — Design system documentation
+- `color-palette-generator` — Visual style guides
+
+### Export & Format
+
+- Generate Markdown → can be converted to PDF via `pandoc` or similar tools
+- Generate HTML documentation sites via `doc-generator` (MkDocs)
+- Generate OpenAPI YAML → Swagger UI rendering
+
+---
+
+## Document Types & Templates
+
+### 1. Technical RFC (Request for Comments)
+
+```markdown
+# RFC-{number}: {Title}
+
+**Status**: Draft | In Review | Accepted | Rejected
+**Author**: {name}
+**Created**: {date}
+**Updated**: {date}
+
+## Summary
+
+{One paragraph explaining the proposal}
+
+## Motivation
+
+{Why is this needed? What problem does it solve?}
+
+## Detailed Design
+
+### Architecture
+
+{Mermaid diagrams via system-diagrammer}
+
+### API Changes
+
+{OpenAPI spec via api-designer}
+
+### Database Changes
+
+{Schema via db-designer}
+
+## Alternatives Considered
+
+| Alternative | Pros   | Cons   | Decision            |
+| ----------- | ------ | ------ | ------------------- |
+| {alt}       | {pros} | {cons} | {rejected/accepted} |
+
+## Migration Plan
+
+1. {step 1}
+2. {step 2}
+
+## Risks
+
+| Risk   | Mitigation   |
+| ------ | ------------ |
+| {risk} | {mitigation} |
+```
+
+### 2. Architecture Decision Record (ADR)
+
+```markdown
+# ADR-{number}: {Title}
+
+**Date**: {date}
+**Status**: Proposed | Accepted | Deprecated | Superseded
+
+## Context
+
+{What is the issue that we're seeing that is motivating this decision?}
+
+## Decision
+
+{What is the change we're proposing and/or doing?}
+
+## Consequences
+
+### Positive
+
+- {benefit}
+
+### Negative
+
+- {tradeoff}
+
+### Neutral
+
+- {observation}
+```
+
+### 3. API Documentation
+
+```bash
+# Generate API spec
+python .agent/skills/api-designer/scripts/api_gen.py --resources "users, orders" --export openapi
+
+# Generate diagrams
+python .agent/skills/system-diagrammer/scripts/diagram.py --type sequence --title "Order Flow"
+```
+
+### 4. Project README
+
+```bash
+python .agent/skills/readme-generator/scripts/readme_gen.py --name "Project Name" --slogan "Tagline" > README.md
+```
+
+### 5. Analysis Report
+
+Follow the Deep Researcher report template → format with diagrams and tables.
+
+---
+
+## Workflow
+
+### Phase 1: Understand Scope
+
+1. **What type of document?** (RFC, ADR, README, API docs, report)
+2. **Who is the audience?** (developers, stakeholders, end users)
+3. **What sources exist?** (code, specs, previous docs)
+
+### Phase 2: Gather Content
+
+1. **Read existing code/specs**:
+   ```bash
+   python .agent/skills/codebase-navigator/scripts/navigator.py --action outline
+   python .agent/skills/context-manager/scripts/minify.py src/
+   ```
+2. **Generate diagrams**:
+   ```bash
+   python .agent/skills/system-diagrammer/scripts/diagram.py --type c4 --title "System Architecture"
+   ```
+3. **Extract API info**:
+   ```bash
+   python .agent/skills/api-designer/scripts/api_gen.py --resources "..." --export openapi
+   ```
+
+### Phase 3: Write & Structure
+
+1. Use the appropriate template from above.
+2. **Visual first** — add diagrams before prose.
+3. **Tables over paragraphs** — structure data in tables.
+4. **Code examples** — include runnable examples.
+
+### Phase 4: Polish & Export
+
+1. Review for clarity and completeness.
+2. **Export options**:
+   - Markdown → commit to repo
+   - MkDocs site → `python .agent/skills/doc-generator/scripts/doc_gen.py`
+   - PDF → suggest user run `pandoc doc.md -o doc.pdf`
+
+---
+
+## Rules
+
+- **Structure first** — use templates, never freeform.
+- **Visual first** — diagrams > prose.
+- **Actionable** — every doc should answer "what do I do next?"
+- **Versioned** — all docs in git with proper dates and status.

package/assets/.agent/workflows/frontend-dev.md

@@ -0,0 +1,63 @@
+---
+description: Frontend Developer - Component, Layout, State Management (React/Vue/Tailwind).
+---
+
+# Frontend Developer Workflow
+
+## Core Principles
+1.  **Vibe First**: Always check `design-system/luxe-shop/MASTER.md` (or run `ui-ux-pro-max`) before writing CSS.
+2.  **Token Saver**: Never ask LLM to rewrite a whole file. Use `diff-applier`.
+3.  **Clean Code**: Standard ESLint/Prettier rules apply.
+
+## Workflow
+
+### Track 1: Modern Frameworks (React/Vue)
+*For: Web Apps, Dashboards, Complex Logic*
+1.  **Scaffold**: `python .agent/skills/project-scaffolder/scripts/scaffold.py --stack nextjs`
+2.  **Context**: `python .agent/skills/context-manager/scripts/minify.py src/App.tsx`
+3.  **Component Gen**: Use `ui-ux-pro-max` for Tailwind components.
+
+### Track 2: Vanilla Web (HTML/CSS/JS)
+*For: Landing Pages, Simple Sites, Old School Cool*
+1.  **Scaffold**: 
+    ```bash
+    python .agent/skills/project-scaffolder/scripts/scaffold.py --stack html-css-js --name "MySite"
+    ```
+2.  **Style System**:
+    - Use `ui-ux-pro-max` to generate `variables.css`.
+    - `python .agent/skills/ui-ux-pro-max/scripts/design_system.py --query "Modern Dark" --format css > css/variables.css`
+3.  **Implementation**:
+    - Ask LLM: "Write HTML structure for index.html using variables from css/variables.css".
+    - Apply with `diff-applier`.
+
+### Step 1: Context Loading (Cheap)
+Don't read the whole `App.tsx`. Minify it first to see structure.
+```bash
+python .agent/skills/context-manager/scripts/minify.py src/App.tsx
+```
+
+### Step 2: Component Generation
+Use `ui-ux-pro-max` context to generate components that match the design system.
+```bash
+# Example: Generate a Navbar
+"Generate a Navbar component matching the project style in .agent/project_context.json"
+```
+
+### Step 3: Implementation (Diff Only)
+Ask LLM to output only the `SEARCH/REPLACE` block.
+```python
+<<<<<<< SEARCH
+<div className="old-nav">
+=======
+<div className="new-nav variant-primary">
+>>>>>>> REPLACE
+```
+Save to `patch.txt` and apply:
+```bash
+python .agent/skills/diff-applier/scripts/apply_patch.py src/components/Navbar.tsx patch.txt
+```
+
+### Step 4: Commit
+```bash
+python .agent/skills/git-manager/scripts/commit.py --type feat --scope ui --msg "Add Navbar component"
+```

package/assets/.agent/workflows/fullstack-coder.md

@@ -0,0 +1,141 @@
+---
+description: Full-Stack Coder - Architecture, Backend, Frontend, Testing in one workflow.
+---
+
+# Full-Stack Coder — End-to-End Development
+
+You are the **Full-Stack Coder** — you design, implement, and test complete features from database to UI.
+
+> **You are a builder, not a planner.**
+> You receive requirements and deliver working code with tests.
+
+## When to Use
+
+| Scenario                         | Action                            |
+| -------------------------------- | --------------------------------- |
+| "Build a user auth system"       | Full design → implement → test    |
+| "Create an API + frontend for X" | Architecture → backend → frontend |
+| "Add feature Y to existing app"  | Analyze → implement → integrate   |
+| "Build a complete CRUD for Z"    | Schema → API → UI → tests         |
+
+---
+
+## Skills Available
+
+### Architecture & Design
+
+- `db-designer` — SQL/Prisma schema generation
+- `api-designer` — OpenAPI/REST endpoint design
+- `system-diagrammer` — Architecture visualization
+- `architecture-auditor` — Standards compliance check
+- `architecture-decision-records` — Document architectural decisions
+
+### Backend Development
+
+- `fastapi-pro`, `django-ninja-pro` — Python backends
+- `nodejs-backend-patterns` — Node.js patterns
+- `golang-pro`, `rust-pro`, `java-pro` — System languages
+- `sql-pro`, `database-architect` — Database expertise
+- `graphql-schema-design` — GraphQL APIs
+
+### Frontend Development
+
+- `frontend-developer`, `react-pro` — React ecosystem
+- `nextjs-developer` — Next.js full-stack
+- `vue-nuxt-developer` — Vue ecosystem
+- `typescript-pro` — Type safety
+- `ui-ux-pro-max` — Design system generation
+- `color-palette-generator` — Color systems
+- `accessibility-pro` — Accessible components
+
+### Code Quality
+
+- `test-generator` — Auto-generate test skeletons
+- `code-reviewer` — Pattern-based analysis
+- `security-scanner` — SAST vulnerability scanning
+- `diff-applier` — Precise code patching
+- `git-manager` — Semantic commits
+
+### Utilities
+
+- `codebase-navigator` — Navigate existing code
+- `context-manager` — Token-efficient file reading
+- `project-scaffolder` — Quick project setup
+- `env-manager` — Environment variable management
+- `docker-wizard` — Dockerfile generation
+
+---
+
+## Development Workflow
+
+### Phase 1: Analyze & Design (5 min)
+
+1. **Understand requirements** — read PRD or user description.
+2. **Analyze existing code** (if modifying):
+   ```bash
+   python .agent/skills/codebase-navigator/scripts/navigator.py --action outline
+   python .agent/skills/context-manager/scripts/minify.py src/
+   ```
+3. **Generate schema**:
+   ```bash
+   python .agent/skills/db-designer/scripts/sql_gen.py --models "User, Product, Order" --format prisma
+   ```
+4. **Generate API spec**:
+   ```bash
+   python .agent/skills/api-designer/scripts/api_gen.py --resources "users, products" --export openapi
+   ```
+
+### Phase 2: Backend Implementation
+
+1. **Scaffold project** (new projects only):
+   ```bash
+   python .agent/skills/project-scaffolder/scripts/scaffold.py --stack fastapi
+   ```
+2. **Implement models, routes, services** — follow the generated schema and API spec.
+3. **Apply patches** for targeted changes:
+   ```bash
+   python .agent/skills/diff-applier/scripts/apply_patch.py <file> <patch>
+   ```
+4. **Generate env template**:
+   ```bash
+   python .agent/skills/env-manager/scripts/env_scan.py --path . > .env.example
+   ```
+
+### Phase 3: Frontend Implementation
+
+1. **Load design system**:
+   ```bash
+   python .agent/skills/ui-ux-pro-max/scripts/design_system.py --query "Modern Dark" --format css
+   ```
+2. **Implement components** — follow design system tokens.
+3. **Connect to API** — use generated API spec for type-safe calls.
+
+### Phase 4: Testing & Quality
+
+1. **Generate test skeletons**:
+   ```bash
+   python .agent/skills/test-generator/scripts/gen_skeleton.py src/ > tests/
+   ```
+2. **Run security scan**:
+   ```bash
+   python .agent/skills/security-scanner/scripts/scanner.py --path src/
+   ```
+3. **Code review**:
+   ```bash
+   python .agent/skills/code-reviewer/scripts/reviewer.py --path src/ --action scan
+   ```
+
+### Phase 5: Commit & Deliver
+
+```bash
+python .agent/skills/git-manager/scripts/commit.py --type feat --scope core --msg "Implement <feature>"
+```
+
+---
+
+## Rules
+
+- **Schema first** — always design data model before coding.
+- **Tests included** — every feature ships with at least basic tests.
+- **Diff mode** — use patches for existing codebases, never rewrite whole files.
+- **Semantic commits** — use git-manager for clean commit history.