@thanhthi2895/luna-ai 2.16.2

package/agentic/claude/.claude/skills/bootstrap/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: lu:bootstrap
+description: "Bootstrap new projects with research, tech stack, design, planning, and implementation. Modes: full (interactive), auto (default), fast (skip research), parallel (multi-agent)."
+license: MIT
+argument-hint: "[requirements] [--full|--auto|--fast|--parallel]"
+---
+
+# Bootstrap - New Project Scaffolding
+
+End-to-end project bootstrapping from idea to running code.
+
+**Principles:** YAGNI, KISS, DRY | Token efficiency | Concise reports
+
+## Usage
+
+```
+/bootstrap <user-requirements>
+```
+
+**Flags** (optional, default `--auto`):
+
+| Flag | Mode | Thinking | User Gates | Planning Skill | Cook Skill |
+|------|------|----------|------------|----------------|------------|
+| `--full` | Full interactive | Ultrathink | Every phase | `--hard` | (interactive) |
+| `--auto` | Automatic | Ultrathink | Design only | `--auto` | `--auto` |
+| `--fast` | Quick | Think hard | None | `--fast` | `--auto` |
+| `--parallel` | Multi-agent | Ultrathink | Design only | `--parallel` | `--parallel` |
+
+**Example:**
+```
+/bootstrap "Build a SaaS dashboard with auth" --fast
+/bootstrap "E-commerce platform with Stripe" --parallel
+```
+
+## Workflow Overview
+
+```
+[Git Init] → [Research?] → [Tech Stack?] → [Design?] → [Planning] → [Implementation] → [Test] → [Review] → [Docs] → [Onboard] → [Final]
+```
+
+Each mode loads a specific workflow reference + shared phases.
+
+## Mode Detection
+
+If no flag provided, default to `--auto`.
+
+Load the appropriate workflow reference:
+- `--full`: Load `references/workflow-full.md`
+- `--auto`: Load `references/workflow-auto.md`
+- `--fast`: Load `references/workflow-fast.md`
+- `--parallel`: Load `references/workflow-parallel.md`
+
+All modes share: Load `references/shared-phases.md` for implementation through final report.
+
+## Step 0: Git Init (ALL modes)
+
+Check if Git initialized. If not:
+- `--full`: Ask user if they want to init → `git-manager` subagent (`main` branch)
+- Others: Auto-init via `git-manager` subagent (`main` branch)
+
+## Skill Triggers (MANDATORY)
+
+After early phases (research, tech stack, design), trigger downstream skills:
+
+### Planning Phase
+Activate **plan** skill first to create plan directory + phase files, then pass plan path to cook.
+
+Mode mapping:
+- `--full` → `/plan` (thorough — run research skill first, then plan)
+- `--auto` → `/plan` (standard — research + plan)
+- `--fast` → `/plan` (fast — skip research, derive from task description)
+- `--parallel` → `/plan` (parallel — file ownership + dependency graph)
+
+Planning outputs a plan path. Pass this to cook.
+
+### Implementation Phase
+Activate **cook** skill with the plan path and mode-appropriate flag:
+- `--full` → `/cook <plan-path>` (interactive review gates)
+- `--auto` → `/cook --auto <plan-path>` (skip review gates)
+- `--fast` → `/cook --auto <plan-path>` (skip review gates)
+- `--parallel` → `/cook --parallel <plan-path>` (multi-agent execution)
+
+## Role
+
+Elite software engineering expert specializing in system architecture and technical decisions. Brutally honest about feasibility and trade-offs.
+
+## Critical Rules
+
+- Activate relevant skills from catalog during the process
+- Keep all research reports ≤150 lines
+- All docs written to `./docs` directory
+- Plans written to `./plans` directory using naming from `## Naming` section
+- DO NOT implement code directly — delegate through planning + cook skills
+- Sacrifice grammar for concision in reports
+- List unresolved questions at end of reports
+
+## References
+
+- `references/workflow-full.md` - Full interactive workflow
+- `references/workflow-auto.md` - Auto workflow (default)
+- `references/workflow-fast.md` - Fast workflow
+- `references/workflow-parallel.md` - Parallel workflow
+- `references/shared-phases.md` - Common phases (implementation → final report)

package/agentic/claude/.claude/skills/bootstrap/references/shared-phases.md

@@ -0,0 +1,59 @@
+# Shared Phases (All Modes)
+
+These phases apply after planning is complete and cook skill is activated.
+Cook skill handles most of these — this reference documents bootstrap-specific guidance.
+
+## Implementation
+
+Handled by **cook** skill. Bootstrap-specific notes:
+- Use main agent to implement step by step per plan in `./plans`
+- Use `ui-ux-designer` subagent for frontend per `./docs/design-guidelines.md`
+- Asset pipeline: `ai-multimodal` (generate/analyze) → `imagemagick` (crop/resize) → background removal if needed
+- Run type checking and compile after each phase
+
+## Testing
+
+Handled by **cook** skill. Bootstrap-specific notes:
+- Write real tests — NO fake data, mocks, cheats, tricks, temporary solutions
+- `tester` subagent runs tests → report to main agent
+- If failures: `debugger` subagent → fix → repeat until all pass
+- DO NOT ignore failed tests to pass build/CI
+
+## Code Review
+
+Handled by **cook** skill. Bootstrap-specific notes:
+- `code-reviewer` subagent reviews code
+- If critical issues: fix → retest → repeat
+- Report summary to user when all tests pass and code reviewed
+
+## Documentation
+
+After code review passes. Use `docs-manager` subagent to create/update:
+- `./docs/README.md` (≤300 lines)
+- `./docs/codebase-summary.md`
+- `./docs/project-overview-pdr.md` (Product Development Requirements)
+- `./docs/code-standards.md`
+- `./docs/system-architecture.md`
+
+Use `project-manager` subagent to create:
+- `./docs/project-roadmap.md`
+- Update plan/phase status to complete
+
+## Onboarding
+
+Guide user to get started with the project:
+- Ask 1 question at a time, wait for answer before next
+- Example: instruct user to obtain API key → ask for key → add to env vars
+- If user requests config changes, repeat until approved
+
+## Final Report
+
+1. Summary of all changes, brief explanations
+2. Guide user to get started + suggest next steps
+3. Ask user if they want to commit/push:
+   - If yes: `git-manager` subagent to commit (and push if requested)
+   - `--fast` mode: auto-commit (no push) without asking
+
+**Report rules:**
+- Sacrifice grammar for concision
+- List unresolved questions at end, if any

package/agentic/claude/.claude/skills/bootstrap/references/workflow-auto.md

@@ -0,0 +1,52 @@
+# Auto Workflow (`--auto`) — Default
+
+**Thinking level:** Ultrathink
+**User gates:** Design approval only. All other phases proceed automatically.
+
+## Step 1: Research
+
+Spawn multiple `researcher` subagents in parallel:
+- Explore request, idea validation, challenges, best solutions
+- Keep every report ≤150 lines
+
+No user gate — proceed automatically.
+
+## Step 2: Tech Stack
+
+1. Use `planner` + multiple `researcher` subagents in parallel for best-fit stack
+2. Write tech stack to `./docs` directory
+
+No user gate — auto-select best option.
+
+## Step 3: Wireframe & Design
+
+1. Use `ui-ux-designer` + `researcher` subagents in parallel:
+   - Research style, trends, fonts (predict Google Fonts name, NOT just Inter/Poppins), colors, spacing, positions
+   - Describe assets for `ai-multimodal` skill generation
+2. `ui-ux-designer` creates:
+   - Design guidelines at `./docs/design-guidelines.md`
+   - Wireframes in HTML at `./docs/wireframe/`
+3. If no logo provided: generate with `ai-multimodal` skill
+4. Screenshot wireframes with `chrome-devtools` → save to `./docs/wireframes/`
+
+**Gate:** Ask user to approve design. Repeat if rejected.
+
+**Image tools:** `ai-multimodal` for generation/analysis, `imagemagick` for crop/resize, background removal tool as needed.
+
+## Step 4: Planning
+
+Activate **plan** skill: `/plan --auto <requirements>`
+- Planning skill auto-detects complexity and picks appropriate mode
+- Creates plan directory using `## Naming` pattern
+- Overview at `plan.md` (<80 lines) + `phase-XX-*.md` files
+
+No user gate — proceed to implementation.
+
+## Step 5: Implementation → Final Report
+
+Load `references/shared-phases.md` for remaining phases.
+
+Activate **cook** skill: `/cook --auto <plan-path>`
+- Skips all review gates
+- Auto-approves if score≥9.5 and 0 critical issues
+- Continues through all phases without stopping

package/agentic/claude/.claude/skills/bootstrap/references/workflow-fast.md

@@ -0,0 +1,50 @@
+# Fast Workflow (`--fast`)
+
+**Thinking level:** Think hard
+**User gates:** None. Fully autonomous from start to finish.
+
+## Step 1: Combined Research & Planning
+
+All research happens in parallel, then feeds into planning:
+
+**Parallel research batch** (spawn these simultaneously):
+- 2 `researcher` subagents (max 5 sources each): explore request, validate idea, find solutions
+- 2 `researcher` subagents (max 5 sources each): find best-fit tech stack
+- 2 `researcher` subagents (max 5 sources each): research design style, trends, fonts, colors, spacing, positions
+  - Predict Google Fonts name (NOT just Inter/Poppins)
+  - Describe assets for `ai-multimodal` generation
+
+Keep all reports ≤150 lines.
+
+## Step 2: Design
+
+1. `ui-ux-designer` subagent analyzes research, creates:
+   - Design guidelines at `./docs/design-guidelines.md`
+   - Wireframes in HTML at `./docs/wireframe/`
+2. If no logo provided: generate with `ai-multimodal` skill
+3. Screenshot wireframes with `chrome-devtools` → save to `./docs/wireframes/`
+
+**Image tools:** `ai-multimodal` for generation/analysis, `imagemagick` for crop/resize, background removal tool as needed.
+
+No user gate — proceed directly.
+
+## Step 3: Planning
+
+Activate **plan** skill: `/plan --fast <requirements>`
+- Skip research (already done above)
+- Read codebase docs → create plan directly
+- Plan directory using `## Naming` pattern
+- Overview at `plan.md` (<80 lines) + `phase-XX-*.md` files
+
+No user gate — proceed to implementation.
+
+## Step 4: Implementation → Final Report
+
+Load `references/shared-phases.md` for remaining phases.
+
+Activate **cook** skill: `/cook --auto <plan-path>`
+- Skips all review gates (fast planning pairs with fast execution)
+- Auto-approves if score≥9.5 and 0 critical issues
+- Continues through all phases without stopping
+
+**Note:** Fast mode uses `git-manager` to auto-commit (no push) at the end.

package/agentic/claude/.claude/skills/bootstrap/references/workflow-full.md

@@ -0,0 +1,60 @@
+# Full Interactive Workflow (`--full`)
+
+**Thinking level:** Ultrathink
+**User gates:** Every major phase requires user approval before proceeding.
+
+## Step 1: Clarify Requirements
+
+Use `AskUserQuestion` to probe user's request, constraints, true objectives.
+- Ask 1 question at a time, wait for answer before next
+- Question everything — don't assume
+- Challenge assumptions — best solution often differs from initial vision
+- Continue until 100% certain about requirements
+
+## Step 2: Research
+
+Spawn multiple `researcher` subagents in parallel:
+- Explore request validity, challenges, best solutions
+- Keep every report ≤150 lines
+
+**Gate:** Present findings to user. Proceed only with approval.
+
+## Step 3: Tech Stack
+
+1. Ask user for preferred tech stack. If provided, skip to step 4.
+2. Use `planner` + multiple `researcher` subagents in parallel to find best-fit stack
+3. Present 2-3 options with pros/cons via `AskUserQuestion`
+4. Write approved tech stack to `./docs` directory
+
+**Gate:** User approves tech stack before continuing.
+
+## Step 4: Wireframe & Design
+
+1. Ask user if they want wireframes/design. If no → skip to Step 5.
+2. Use `ui-ux-designer` + `researcher` subagents in parallel:
+   - Research style, trends, fonts (predict Google Fonts name, NOT just Inter/Poppins), colors, spacing, positions
+   - Describe assets for `ai-multimodal` skill generation
+3. `ui-ux-designer` creates:
+   - Design guidelines at `./docs/design-guidelines.md`
+   - Wireframes in HTML at `./docs/wireframe/`
+4. If no logo provided: generate with `ai-multimodal` skill
+5. Screenshot wireframes with `chrome-devtools` → save to `./docs/wireframes/`
+
+**Gate:** User approves design. Repeat if rejected.
+
+**Image tools:** `ai-multimodal` for generation/analysis, `imagemagick` for crop/resize, background removal tool as needed.
+
+## Step 5: Planning
+
+Activate **plan** skill: `/plan --hard <requirements>`
+- Planner creates directory using `## Naming` pattern
+- Overview at `plan.md` (<80 lines) + `phase-XX-*.md` files
+- Present pros/cons of plan
+
+**Gate:** User approves plan. DO NOT start implementing without approval.
+
+## Step 6: Implementation → Final Report
+
+Load `references/shared-phases.md` for remaining phases.
+
+Activate **cook** skill: `/cook <plan-path>` (interactive mode — review gates at each step)

package/agentic/claude/.claude/skills/bootstrap/references/workflow-parallel.md

@@ -0,0 +1,59 @@
+# Parallel Workflow (`--parallel`)
+
+**Thinking level:** Ultrathink parallel
+**User gates:** Design approval only. Implementation uses multi-agent parallel execution.
+
+## Step 1: Research
+
+Spawn max 2 `researcher` agents in parallel:
+- Explore requirements, validation, challenges, solutions
+- Keep reports ≤150 lines
+
+No user gate — proceed automatically.
+
+## Step 2: Tech Stack
+
+Use `planner` + multiple `researcher` agents in parallel for best-fit stack.
+Write to `./docs` directory (≤150 lines).
+
+No user gate — proceed automatically.
+
+## Step 3: Wireframe & Design
+
+1. Use `ui-ux-designer` + `researcher` agents in parallel:
+   - Research style, trends, fonts, colors, spacing, positions
+   - Predict Google Fonts name (NOT just Inter/Poppins)
+   - Describe assets for `ai-multimodal` generation
+2. `ui-ux-designer` creates:
+   - Design guidelines at `./docs/design-guidelines.md`
+   - Wireframes in HTML at `./docs/wireframe/`
+3. If no logo: generate with `ai-multimodal` skill
+4. Screenshot with `chrome-devtools` → save to `./docs/wireframes/`
+
+**Gate:** Ask user to approve design. Repeat if rejected.
+
+**Image tools:** `ai-multimodal` for generation/analysis, `imagemagick` for crop/resize, background removal tool as needed.
+
+## Step 4: Parallel Planning
+
+Activate **plan** skill: `/plan --parallel <requirements>`
+- Creates phases with **exclusive file ownership** per phase (no overlap)
+- **Dependency matrix**: which phases run concurrently vs sequentially
+- `plan.md` includes dependency graph, execution strategy, file ownership matrix
+- Task hydration with `addBlockedBy` for sequential deps, no blockers for parallel groups
+
+No user gate — proceed to implementation.
+
+## Step 5: Parallel Implementation → Final Report
+
+Load `references/shared-phases.md` for remaining phases.
+
+Activate **cook** skill: `/cook --parallel <plan-path>`
+- Read `plan.md` for dependency graph and execution strategy
+- Launch multiple `fullstack-developer` agents in PARALLEL for concurrent phases
+  - Pass: phase file path, environment info
+- Use `ui-ux-designer` for frontend (generate/analyze assets with `ai-multimodal`, edit with `imagemagick`)
+- Respect file ownership boundaries
+- Run type checking after implementation
+
+Cook handles testing, review, docs, onboarding, final report per `shared-phases.md`.

package/agentic/claude/.claude/skills/brainstorm/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: lu:brainstorm
+author: luna
+description: "Brainstorm solutions with trade-off analysis and brutal honesty. Use for ideation, architecture decisions, technical debates, feature exploration, feasibility assessment, design discussions."
+version: 1.0.0
+argument-hint: "[topic or problem]"
+---
+
+# Brainstorming
+
+Elite software engineering advisor for system architecture and technical decision-making. Core mission: find best solutions with brutal honesty about feasibility and trade-offs.
+
+## Core Principles
+
+**YAGNI / KISS / DRY** — every solution must honor these.
+
+## Approach
+
+1. **Question Everything** — Use `AskUserQuestion` to fully understand requirements, constraints, true objectives
+2. **Brutal Honesty** — Frank, unfiltered feedback. If unrealistic or over-engineered, say so directly
+3. **Explore Alternatives** — Always present 2-3 viable solutions with clear pros/cons
+4. **Challenge Assumptions** — Question the initial approach. Best solution is often different from what was envisioned
+5. **Consider All Stakeholders** — Evaluate impact on end users, developers, ops team, business objectives
+
+## Tools
+
+- `scout` skill — discover relevant files and code patterns
+- `research` skill — understand existing project implementation
+- `sequential-thinking` skill — for complex analysis requiring structured reasoning
+- `WebSearch` — find efficient approaches from others' experiences
+- `docs-seeker` skill — read latest documentation of external packages
+
+## Process
+
+1. **Scout Phase** — Use `scout` skill to discover relevant files, read relevant docs
+2. **Discovery Phase** — `AskUserQuestion` to clarify requirements, constraints, timeline, success criteria
+3. **Research Phase** — Gather info from agents and external sources
+4. **Analysis Phase** — Evaluate multiple approaches
+5. **Debate Phase** — Present options, challenge user preferences, work toward optimal solution
+6. **Consensus Phase** — Align on chosen approach and document decisions
+7. **Documentation Phase** — Create markdown summary report
+8. **Finalize Phase** — Ask if user wants a detailed implementation plan
+   - If Yes: Use `plan` skill with brainstorm summary as context
+   - If No: End session
+
+## Report Output
+
+Use naming pattern from `## Naming` section injected by dev-rules-reminder hook.
+
+## Output Requirements
+
+- Problem statement and requirements
+- Evaluated approaches with pros/cons
+- Final recommended solution with rationale
+- Implementation considerations and risks
+- Next steps and dependencies
+- Sacrifice grammar for concision
+
+## Critical Constraints
+
+- **DO NOT implement** — only brainstorm and advise
+- Validate feasibility before endorsing any approach
+- Prioritize long-term maintainability over short-term convenience

package/agentic/claude/.claude/skills/ccc/SKILL.md

@@ -0,0 +1,71 @@
+---
+name: ccc
+description: "This skill should be used when code search is needed (whether explicitly requested or as part of completing a task), when indexing the codebase after changes, or when the user asks about ccc, cocoindex-code, or the codebase index. Trigger phrases include 'search the codebase', 'find code related to', 'update the index', 'ccc', 'cocoindex-code'."
+---
+
+# ccc - Semantic Code Search & Indexing
+
+`ccc` is the CLI for CocoIndex Code, providing semantic search over the current codebase and index management.
+
+## Ownership
+
+The agent owns the `ccc` lifecycle for the current project — initialization, indexing, and searching. Do not ask the user to perform these steps; handle them automatically.
+
+- **Initialization**: If `ccc search` or `ccc index` fails with an initialization error (e.g., "Not in an initialized project directory"), run `ccc init` from the project root directory, then `ccc index` to build the index, then retry the original command.
+- **Index freshness**: Keep the index up to date by running `ccc index` (or `ccc search --refresh`) when the index may be stale — e.g., at the start of a session, or after making significant code changes (new files, refactors, renamed modules). There is no need to re-index between consecutive searches if no code was changed in between.
+- **Installation**: If `ccc` itself is not found (command not found), refer to [management.md](references/management.md) for installation instructions and inform the user.
+
+## Searching the Codebase
+
+To perform a semantic search:
+
+```bash
+ccc search <query terms>
+```
+
+The query should describe the concept, functionality, or behavior to find, not exact code syntax. For example:
+
+```bash
+ccc search database connection pooling
+ccc search user authentication flow
+ccc search error handling retry logic
+```
+
+### Filtering Results
+
+- **By language** (`--lang`, repeatable): restrict results to specific languages.
+
+  ```bash
+  ccc search --lang python --lang markdown database schema
+  ```
+
+- **By path** (`--path`): restrict results to a glob pattern relative to project root. If omitted, defaults to the current working directory (only results under that subdirectory are returned).
+
+  ```bash
+  ccc search --path 'src/api/*' request validation
+  ```
+
+### Pagination
+
+Results default to the first page. To retrieve additional results:
+
+```bash
+ccc search --offset 5 --limit 5 database schema
+```
+
+If all returned results look relevant, use `--offset` to fetch the next page — there are likely more useful matches beyond the first page.
+
+### Working with Search Results
+
+Search results include file paths and line ranges. To explore a result in more detail:
+
+- Use the editor's built-in file reading capabilities (e.g., the `Read` tool) to load the matched file and read lines around the returned range for full context.
+- When working in a terminal without a file-reading tool, use `sed -n '<start>,<end>p' <file>` to extract a specific line range.
+
+## Settings
+
+To view or edit embedding model configuration, include/exclude patterns, or language overrides, see [settings.md](references/settings.md).
+
+## Management & Troubleshooting
+
+For installation, initialization, daemon management, troubleshooting, and cleanup commands, see [management.md](references/management.md).

package/agentic/claude/.claude/skills/ccc/references/management.md

@@ -0,0 +1,85 @@
+# ccc Management
+
+## Installation
+
+Install CocoIndex Code via pipx:
+
+```bash
+pipx install cocoindex-code
+```
+
+To upgrade to the latest version:
+
+```bash
+pipx upgrade cocoindex-code
+```
+
+After installation, the `ccc` command is available globally.
+
+## Project Initialization
+
+Run from the root directory of the project to index:
+
+```bash
+ccc init
+```
+
+This creates:
+- `~/.cocoindex_code/global_settings.yml` (user-level settings, e.g., model configuration) if it does not already exist.
+- `.cocoindex_code/settings.yml` (project-level settings, e.g., include/exclude file patterns).
+
+If `.git` exists in the directory, `.cocoindex_code/` is automatically added to `.gitignore`.
+
+Use `-f` to skip the confirmation prompt if `ccc init` detects a potential parent project root.
+
+After initialization, edit the settings files if needed (see [settings.md](settings.md) for format details), then run `ccc index` to build the initial index.
+
+## Troubleshooting
+
+### Checking Project Status
+
+To view the current project's index status:
+
+```bash
+ccc status
+```
+
+This shows whether indexing is ongoing and index statistics.
+
+### Daemon Management
+
+The daemon starts automatically on first use. To check its status:
+
+```bash
+ccc daemon status
+```
+
+This shows whether the daemon is running, its version, uptime, and loaded projects.
+
+To restart the daemon (useful if it gets into a bad state):
+
+```bash
+ccc daemon restart
+```
+
+To stop the daemon:
+
+```bash
+ccc daemon stop
+```
+
+## Cleanup
+
+To reset a project's index (removes databases, keeps settings):
+
+```bash
+ccc reset
+```
+
+To fully remove all CocoIndex Code data for a project (including settings):
+
+```bash
+ccc reset --all
+```
+
+Both commands prompt for confirmation. Use `-f` to skip.