@manhnv319/codexkit 0.1.0

package/.agents/skills/docs/references/init-workflow.md

@@ -0,0 +1,32 @@
+# Init Workflow
+
+## Phase 1: Parallel Codebase Scouting
+
+1. Scan the codebase and calculate the number of files with LOC in each directory (skip credentials, cache or external modules directories, such as `.claude`, `.opencode`, `.git`, `tests`, `node_modules`, `__pycache__`, `secrets`, etc.)
+2. Target directories **that actually exist** - adapt to project structure, don't hardcode paths
+3. Activate `ck:scout` skill to explore the code base and return detailed summary reports to the main agent
+4. Merge scout reports into context summary
+
+## Phase 2: Documentation Creation (docs_manager Agent)
+
+**CRITICAL:** You MUST spawn `docs_manager` agent via Task tool with merged reports. Do not wait for user input.
+
+Pass the gathered context to docs_manager agent to create initial documentation:
+- `README.md`: Update README with initial documentation (keep it under 300 lines)
+- `docs/project-overview-pdr.md`: Project overview and PDR (Product Development Requirements)
+- `docs/codebase-summary.md`: Codebase summary
+- `docs/code-standards.md`: Codebase structure and code standards
+- `docs/system-architecture.md`: System architecture
+- `docs/project-roadmap.md`: Project roadmap
+- `docs/deployment-guide.md` [optional]: Deployment guide
+- `docs/design-guidelines.md` [optional]: Design guidelines
+
+## Phase 3: Size Check (Post-Generation)
+
+After docs_manager completes:
+1. Run `wc -l docs/*.md 2>/dev/null | sort -rn` to check LOC
+2. Use `docs.maxLoc` from session context (default: 800)
+3. For files exceeding limit:
+   - Report which files exceed and by how much
+   - docs_manager should have already split proactively
+   - If still oversized, ask user: split now or accept as-is?

package/.agents/skills/docs/references/summarize-workflow.md

@@ -0,0 +1,18 @@
+# Summarize Workflow
+
+Activate `ck:scout` skill to analyze the codebase and update `docs/codebase-summary.md` and respond with a summary report.
+
+## Arguments
+$1: Focused topics (default: all)
+$2: Should scan codebase (`Boolean`, default: `false`)
+
+## Focused Topics
+<focused_topics>$1</focused_topics>
+
+## Should Scan Codebase
+<should_scan_codebase>$2</should_scan_codebase>
+
+## Important
+- Use `docs/` directory as the source of truth for documentation.
+- Do not scan the entire codebase unless the user explicitly requests it.
+- **Do not** start implementing.

package/.agents/skills/docs/references/update-workflow.md

@@ -0,0 +1,59 @@
+# Update Workflow
+
+## Phase 1: Parallel Codebase Scouting
+
+1. Scan the codebase and calculate the number of files with LOC in each directory (skip `.claude`, `.opencode`, `.git`, `tests`, `node_modules`, `__pycache__`, `secrets`, etc.)
+2. Target directories **that actually exist** - adapt to project structure
+3. Activate `ck:scout` skill to explore the code base and return detailed summary reports
+4. Merge scout reports into context summary
+
+## Phase 1.5: Parallel Documentation Reading
+
+**You (main agent) must spawn readers** - subagents cannot spawn subagents.
+
+1. Count docs: `ls docs/*.md 2>/dev/null | wc -l`
+2. Get LOC: `wc -l docs/*.md 2>/dev/null | sort -rn`
+3. Strategy:
+   - 1-3 files: Skip parallel reading, docs_manager reads directly
+   - 4-6 files: Spawn 2-3 `Explore` agents
+   - 7+ files: Spawn 4-5 `Explore` agents (max 5)
+4. Distribute files by LOC (larger files get dedicated agent)
+5. Each agent prompt: "Read these docs, extract: purpose, key sections, areas needing update. Files: {list}"
+6. Merge results into context for docs_manager
+
+## Phase 2: Documentation Update (docs_manager Agent)
+
+**CRITICAL:** You MUST spawn `docs_manager` agent via Task tool with merged reports and doc readings.
+
+Pass the gathered context to docs_manager agent to update documentation:
+- `README.md`: Update README (keep it under 300 lines)
+- `docs/project-overview-pdr.md`: Update project overview and PDR
+- `docs/codebase-summary.md`: Update codebase summary
+- `docs/code-standards.md`: Update codebase structure and code standards
+- `docs/system-architecture.md`: Update system architecture
+- `docs/project-roadmap.md`: Update project roadmap
+- `docs/deployment-guide.md` [optional]: Update deployment guide
+- `docs/design-guidelines.md` [optional]: Update design guidelines
+
+## Additional requests
+<additional_requests>
+  $ARGUMENTS
+</additional_requests>
+
+## Phase 3: Size Check (Post-Update)
+
+After docs_manager completes:
+1. Run `wc -l docs/*.md 2>/dev/null | sort -rn` to check LOC
+2. Use `docs.maxLoc` from session context (default: 800)
+3. For files exceeding limit: report and ask user
+
+## Phase 4: Documentation Validation (Post-Update)
+
+Run validation to detect potential hallucinations:
+1. Run: `node .codex/scripts/validate-docs.cjs docs/`
+2. Display validation report (warnings only, non-blocking)
+3. Checks: code references, internal links, config keys
+
+## Important
+- Use `docs/` directory as the source of truth.
+- **Do not** start implementing.

package/.agents/skills/docs-seeker/.env.example

@@ -0,0 +1,15 @@
+# Context7 API Configuration (optional)
+# Get your API key from https://context7.com/dashboard/api-keys
+CONTEXT7_API_KEY=
+
+# Gemini API Configuration (optional, for ai-multimodal integration)
+# Get your API key from https://aistudio.google.com/app/apikey
+GEMINI_API_KEY=
+
+# GitHub Token (optional, for higher rate limits on repository analysis)
+# Create at https://github.com/settings/tokens
+GITHUB_TOKEN=
+
+# Output settings
+OUTPUT_FORMAT=json
+DEBUG=false

package/.agents/skills/docs-seeker/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: ck:docs-seeker
+description: Search library/framework documentation via llms.txt (context7.com). Use for API docs, GitHub repository analysis, technical documentation lookup, latest library features.
+version: 3.1.0
+argument-hint: "[library-name] [topic]"
+---
+
+# Documentation Discovery via Scripts
+
+## Overview
+
+**Script-first** documentation discovery using llms.txt standard.
+
+Execute scripts to handle entire workflow - no manual URL construction needed.
+
+## Primary Workflow
+
+**ALWAYS execute scripts in this order:**
+
+```bash
+# 1. DETECT query type (topic-specific vs general)
+node scripts/detect-topic.js "<user query>"
+
+# 2. FETCH documentation using script output
+node scripts/fetch-docs.js "<user query>"
+
+# 3. ANALYZE results (if multiple URLs returned)
+cat llms.txt | node scripts/analyze-llms-txt.js -
+```
+
+Scripts handle URL construction, fallback chains, and error handling automatically.
+
+## Scripts
+
+**`detect-topic.js`** - Classify query type
+- Identifies topic-specific vs general queries
+- Extracts library name + topic keyword
+- Returns JSON: `{topic, library, isTopicSpecific}`
+- Zero-token execution
+
+**`fetch-docs.js`** - Retrieve documentation
+- Constructs context7.com URLs automatically
+- Handles fallback: topic → general → error
+- Outputs llms.txt content or error message
+- Zero-token execution
+
+**`analyze-llms-txt.js`** - Process llms.txt
+- Categorizes URLs (critical/important/supplementary)
+- Recommends agent distribution (1 agent, 3 agents, 7 agents, phased)
+- Returns JSON with strategy
+- Zero-token execution
+
+## Workflow References
+
+**[Topic-Specific Search](./workflows/topic-search.md)** - Fastest path (10-15s)
+
+**[General Library Search](./workflows/library-search.md)** - Comprehensive coverage (30-60s)
+
+**[Repository Analysis](./workflows/repo-analysis.md)** - Fallback strategy
+
+## References
+
+**[context7-patterns.md](./references/context7-patterns.md)** - URL patterns, known repositories
+
+**[errors.md](./references/errors.md)** - Error handling, fallback strategies
+
+**[advanced.md](./references/advanced.md)** - Edge cases, versioning, multi-language
+
+## Execution Principles
+
+1. **Scripts first** - Execute scripts instead of manual URL construction
+2. **Zero-token overhead** - Scripts run without context loading
+3. **Automatic fallback** - Scripts handle topic → general → error chains
+4. **Progressive disclosure** - Load workflows/references only when needed
+5. **Agent distribution** - Scripts recommend parallel agent strategy
+
+## Quick Start
+
+**Topic query:** "How do I use date picker in shadcn?"
+```bash
+node scripts/detect-topic.js "<query>"  # → {topic, library, isTopicSpecific}
+node scripts/fetch-docs.js "<query>"    # → 2-3 URLs
+# Read URLs with WebFetch
+```
+
+**General query:** "Documentation for Next.js"
+```bash
+node scripts/detect-topic.js "<query>"         # → {isTopicSpecific: false}
+node scripts/fetch-docs.js "<query>"           # → 8+ URLs
+cat llms.txt | node scripts/analyze-llms-txt.js -  # → {totalUrls, distribution}
+# Deploy agents per recommendation
+```
+
+## Environment
+
+Scripts load `.env`: `process.env` > `.agents/skills/docs-seeker/.env` > `.agents/skills/.env` > `.codex/.env`
+
+See `.env.example` for configuration options.

package/.agents/skills/docs-seeker/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "docs-seeker-scripts",
+  "version": "3.0.0",
+  "description": "Documentation discovery scripts for docs-seeker skill",
+  "private": true,
+  "scripts": {
+    "test": "node scripts/tests/run-tests.js",
+    "test:detect": "node scripts/tests/test-detect-topic.js",
+    "test:fetch": "node scripts/tests/test-fetch-docs.js",
+    "test:analyze": "node scripts/tests/test-analyze-llms.js"
+  },
+  "keywords": [
+    "documentation",
+    "llms.txt",
+    "context7",
+    "docs-discovery"
+  ],
+  "author": "ClaudeKit",
+  "license": "MIT",
+  "dependencies": {},
+  "devDependencies": {},
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

package/.agents/skills/docs-seeker/references/advanced.md

@@ -0,0 +1,79 @@
+# Advanced Scenarios & Edge Cases
+
+## Multi-Language Documentation
+
+**Challenge:** Docs in multiple languages
+
+**Approach:**
+1. Identify target language from user
+2. Search for language-specific llms.txt
+   - `llms-es.txt`, `llms-ja.txt`
+3. Fallback to English if not found
+4. Note language limitations in report
+
+## Version-Specific Documentation
+
+**Latest (default):**
+- Use base llms.txt URL
+- No version specifier needed
+
+**Specific version:**
+```
+WebSearch: "[library] v[version] llms.txt"
+Check paths:
+- /v2/llms.txt
+- /docs/v2/llms.txt
+- /{version}/llms.txt
+
+For repos:
+git checkout v[version] or tags/[version]
+```
+
+## Framework with Plugins
+
+**Challenge:** Core framework + 50 plugins
+
+**Strategy:**
+1. Focus on core framework first
+2. Ask user which plugins needed
+3. Launch targeted search for specific plugins
+4. Note available plugins in report
+5. Don't document everything upfront
+
+## Documentation Under Construction
+
+**Signs:**
+- New release with incomplete docs
+- Many "Coming soon" pages
+- GitHub issues requesting docs
+
+**Approach:**
+1. Note status upfront in report
+2. Combine available docs + repo analysis
+3. Check tests/ and examples/ directories
+4. Clearly mark "inferred from code"
+5. Link to GitHub issues for updates
+
+## Conflicting Information
+
+**When sources disagree:**
+1. Identify primary official source
+2. Note version differences
+3. Present both approaches with context
+4. Recommend official/latest
+5. Explain why conflict exists
+
+**Priority order:**
+1. Official docs (latest version)
+2. Official docs (versioned)
+3. GitHub README
+4. Community tutorials
+5. Stack Overflow
+
+## Rate Limiting
+
+**If hitting API limits:**
+- Use CONTEXT7_API_KEY from .env
+- Implement exponential backoff
+- Cache results in session
+- Batch requests where possible

package/.agents/skills/docs-seeker/references/context7-patterns.md

@@ -0,0 +1,68 @@
+# context7.com URL Patterns
+
+## Topic-Specific URLs (Priority #1)
+
+**Pattern:** `https://context7.com/{path}/llms.txt?topic={keyword}`
+
+**When to use:** User asks about specific feature/component
+
+**Examples:**
+```
+shadcn/ui date picker
+→ https://context7.com/shadcn-ui/ui/llms.txt?topic=date
+
+Next.js caching
+→ https://context7.com/vercel/next.js/llms.txt?topic=cache
+
+Better Auth OAuth
+→ https://context7.com/better-auth/better-auth/llms.txt?topic=oauth
+
+FFmpeg compression
+→ https://context7.com/websites/ffmpeg_doxygen_8_0/llms.txt?topic=compress
+```
+
+**Benefits:** Returns ONLY relevant docs, 10x faster, minimal tokens
+
+## General Library URLs (Priority #2)
+
+**GitHub repos:** `https://context7.com/{org}/{repo}/llms.txt`
+
+**Websites:** `https://context7.com/websites/{normalized-path}/llms.txt`
+
+## Known Repository Mappings
+
+```
+next.js → vercel/next.js
+nextjs → vercel/next.js
+astro → withastro/astro
+remix → remix-run/remix
+shadcn → shadcn-ui/ui
+shadcn/ui → shadcn-ui/ui
+better-auth → better-auth/better-auth
+```
+
+## Official Site Fallbacks
+
+Use ONLY if context7.com unavailable:
+```
+Astro: https://docs.astro.build/llms.txt
+Next.js: https://nextjs.org/llms.txt
+Remix: https://remix.run/llms.txt
+SvelteKit: https://kit.svelte.dev/llms.txt
+```
+
+## Topic Keyword Normalization
+
+**Rules:**
+- Lowercase
+- Remove special chars
+- Use first word for multi-word topics
+- Max 20 chars
+
+**Examples:**
+```
+"date picker" → "date"
+"OAuth" → "oauth"
+"Server-Side" → "server"
+"caching strategies" → "caching"
+```

package/.agents/skills/docs-seeker/references/errors.md

@@ -0,0 +1,68 @@
+# Error Handling & Fallback Strategies
+
+## Error Codes
+
+**404 Not Found**
+- Topic-specific URL not available
+- Library not on context7.com
+- llms.txt doesn't exist
+
+**Timeout**
+- Network issues
+- Large repository clone
+- Slow API response
+
+**Invalid Response**
+- Malformed llms.txt
+- Empty content
+- Invalid URLs
+
+## Fallback Chain
+
+### For Topic-Specific Queries
+
+```
+1. Try topic-specific URL
+   https://context7.com/{library}/llms.txt?topic={keyword}
+   ↓ 404
+2. Try general library URL
+   https://context7.com/{library}/llms.txt
+   ↓ 404
+3. WebSearch for llms.txt
+   "[library] llms.txt site:[official domain]"
+   ↓ Not found
+4. Repository analysis
+   Use Repomix on GitHub repo
+```
+
+### For General Library Queries
+
+```
+1. Try context7.com
+   https://context7.com/{library}/llms.txt
+   ↓ 404
+2. WebSearch for llms.txt
+   "[library] llms.txt"
+   ↓ Not found
+3. Repository analysis
+   Clone + Repomix
+   ↓ No repo
+4. Research agents
+   Deploy multiple Researcher agents
+```
+
+## Timeout Handling
+
+**Set limits:**
+- WebFetch: 60s
+- Repository clone: 5min
+- Repomix: 10min
+
+**Fail fast:** Don't retry failed methods
+
+## Empty Results
+
+**If llms.txt has 0 URLs:**
+→ Note in report
+→ Try repository analysis
+→ Check official website manually

package/.agents/skills/docs-seeker/scripts/analyze-llms-txt.js

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+
+/**
+ * llms.txt Analyzer Script
+ * Parses llms.txt content and categorizes URLs for optimal agent distribution
+ */
+
+const { loadEnv } = require('./utils/env-loader');
+
+// Load environment
+const env = loadEnv();
+const DEBUG = env.DEBUG === 'true';
+
+/**
+ * URL priority categories
+ */
+const PRIORITY_KEYWORDS = {
+  critical: [
+    'getting-started', 'quick-start', 'quickstart', 'introduction', 'intro', 'overview',
+    'installation', 'install', 'setup', 'basics', 'core-concepts', 'fundamentals',
+  ],
+  supplementary: [
+    'advanced', 'internals', 'migration', 'migrate', 'troubleshooting', 'troubleshoot',
+    'faq', 'frequently-asked', 'changelog', 'contributing', 'contribute',
+  ],
+  important: [
+    'guide', 'tutorial', 'example', 'api-reference', 'api', 'reference',
+    'configuration', 'config', 'routing', 'route', 'data-fetching', 'authentication', 'auth',
+  ],
+};
+
+/**
+ * Categorize URL by priority
+ * @param {string} url - Documentation URL
+ * @returns {string} Priority level (critical/important/supplementary)
+ */
+function categorizeUrl(url) {
+  const urlLower = url.toLowerCase();
+
+  // Check in priority order: critical first, then supplementary, then important
+  // This ensures specific keywords (advanced, internals) are caught before generic ones
+  const priorities = ['critical', 'supplementary', 'important'];
+
+  for (const priority of priorities) {
+    const keywords = PRIORITY_KEYWORDS[priority];
+    for (const keyword of keywords) {
+      if (urlLower.includes(keyword)) {
+        return priority;
+      }
+    }
+  }
+
+  return 'important'; // Default
+}
+
+/**
+ * Parse llms.txt content to extract URLs
+ * @param {string} content - llms.txt content
+ * @returns {Array<string>} Array of URLs
+ */
+function parseUrls(content) {
+  if (!content || typeof content !== 'string') {
+    return [];
+  }
+
+  const urls = [];
+  const lines = content.split('\n');
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    // Skip comments and empty lines
+    if (!trimmed || trimmed.startsWith('#')) continue;
+
+    // Extract URLs (look for http/https)
+    const urlMatch = trimmed.match(/https?:\/\/[^\s<>"]+/i);
+    if (urlMatch) {
+      urls.push(urlMatch[0]);
+    }
+  }
+
+  return urls;
+}
+
+/**
+ * Group URLs by priority
+ * @param {Array<string>} urls - Array of URLs
+ * @returns {Object} URLs grouped by priority
+ */
+function groupByPriority(urls) {
+  const groups = {
+    critical: [],
+    important: [],
+    supplementary: [],
+  };
+
+  for (const url of urls) {
+    const priority = categorizeUrl(url);
+    groups[priority].push(url);
+  }
+
+  return groups;
+}
+
+/**
+ * Suggest optimal agent distribution
+ * @param {number} urlCount - Total number of URLs
+ * @returns {Object} Agent distribution suggestion
+ */
+function suggestAgentDistribution(urlCount) {
+  if (urlCount <= 3) {
+    return {
+      agentCount: 1,
+      strategy: 'single',
+      urlsPerAgent: urlCount,
+      description: 'Single agent can handle all URLs',
+    };
+  } else if (urlCount <= 10) {
+    const agents = Math.min(Math.ceil(urlCount / 2), 5);
+    return {
+      agentCount: agents,
+      strategy: 'parallel',
+      urlsPerAgent: Math.ceil(urlCount / agents),
+      description: `Deploy ${agents} agents in parallel`,
+    };
+  } else if (urlCount <= 20) {
+    return {
+      agentCount: 7,
+      strategy: 'parallel',
+      urlsPerAgent: Math.ceil(urlCount / 7),
+      description: 'Deploy 7 agents with balanced workload',
+    };
+  } else {
+    return {
+      agentCount: 7,
+      strategy: 'phased',
+      urlsPerAgent: Math.ceil(urlCount / 7),
+      phases: 2,
+      description: 'Use two-phase approach: critical first, then important',
+    };
+  }
+}
+
+/**
+ * Analyze llms.txt content
+ * @param {string} content - llms.txt content
+ * @returns {Object} Analysis result
+ */
+function analyzeLlmsTxt(content) {
+  const urls = parseUrls(content);
+  const grouped = groupByPriority(urls);
+  const distribution = suggestAgentDistribution(urls.length);
+
+  return {
+    totalUrls: urls.length,
+    urls,
+    grouped,
+    distribution,
+    summary: {
+      critical: grouped.critical.length,
+      important: grouped.important.length,
+      supplementary: grouped.supplementary.length,
+    },
+  };
+}
+
+/**
+ * CLI entry point
+ */
+function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    console.error('Usage: node analyze-llms-txt.js <content-file-or-stdin>');
+    console.error('Or pipe content: cat llms.txt | node analyze-llms-txt.js');
+    process.exit(1);
+  }
+
+  const fs = require('fs');
+  let content;
+
+  if (args[0] === '-') {
+    // Read from stdin
+    content = fs.readFileSync(0, 'utf8');
+  } else {
+    // Read from file
+    const filePath = args[0];
+    if (!fs.existsSync(filePath)) {
+      console.error(`Error: File not found: ${filePath}`);
+      process.exit(1);
+    }
+    content = fs.readFileSync(filePath, 'utf8');
+  }
+
+  const result = analyzeLlmsTxt(content);
+  console.log(JSON.stringify(result, null, 2));
+  process.exit(0);
+}
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  analyzeLlmsTxt,
+  parseUrls,
+  groupByPriority,
+  categorizeUrl,
+  suggestAgentDistribution,
+};