@thanhthi2895/luna-ai 2.16.2

package/agentic/opencode/.opencode/skills/create-skill/scripts/sync.cjs

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+/**
+ * sync.cjs — Sync Luna skill from repo OpenCode profile to ~/.config/opencode/skills/ via hardlinks
+ *
+ * Usage:
+ *   node sync.cjs <skill-name>
+ *
+ * For each file in agentic/opencode/.opencode/skills/<name>/, creates a hardlink at
+ * ~/.config/opencode/skills/<name>/. Same inode = edits in either location are
+ * instantly reflected in both.
+ *
+ * Safe to re-run: skips files that already share the same inode.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const skillName = process.argv[2];
+
+if (!skillName) {
+  console.error('Usage: node sync.cjs <skill-name>');
+  process.exit(1);
+}
+
+// --- Resolve paths ---
+const cwd = process.cwd();
+const srcRoot = path.join(cwd, 'agentic', 'opencode', '.opencode', 'skills', skillName);
+const destRoot = path.join(os.homedir(), '.config', 'opencode', 'skills', skillName);
+
+if (!fs.existsSync(srcRoot)) {
+  console.error(`❌ Source skill not found: ${srcRoot}`);
+  process.exit(1);
+}
+
+/**
+ * Recursively hardlink all files from srcDir to destDir.
+ * Skips if already same inode (already hardlinked).
+ * Overwrites only if inodes differ (file was replaced).
+ */
+function syncDir(srcDir, destDir) {
+  fs.mkdirSync(destDir, { recursive: true });
+
+  const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+
+    if (entry.isDirectory()) {
+      syncDir(srcPath, destPath);
+      continue;
+    }
+
+    if (!entry.isFile()) continue;
+
+    // Check if already hardlinked (same inode)
+    if (fs.existsSync(destPath)) {
+      const srcStat = fs.statSync(srcPath);
+      const destStat = fs.statSync(destPath);
+
+      if (srcStat.ino === destStat.ino) {
+        console.log(`  ↔  Already linked: ${entry.name}`);
+        continue;
+      }
+
+      // Different inode — remove old and re-link
+      fs.unlinkSync(destPath);
+    }
+
+    // Create hardlink: src → dest
+    fs.linkSync(srcPath, destPath);
+    console.log(`  ✅ Linked: ${path.relative(srcRoot, srcPath)}`);
+  }
+}
+
+console.log(`\n🔗 Syncing lu:${skillName}`);
+console.log(`   src:  ${srcRoot}`);
+console.log(`   dest: ${destRoot}\n`);
+
+try {
+  syncDir(srcRoot, destRoot);
+
+  // Verify inode match for SKILL.md
+  const srcSkill = path.join(srcRoot, 'SKILL.md');
+  const destSkill = path.join(destRoot, 'SKILL.md');
+  if (fs.existsSync(srcSkill) && fs.existsSync(destSkill)) {
+    const s = fs.statSync(srcSkill);
+    const d = fs.statSync(destSkill);
+    if (s.ino === d.ino) {
+      console.log(`\n✅ SKILL.md hardlink verified (inode ${s.ino})`);
+    } else {
+      console.warn(`\n⚠️  SKILL.md inode mismatch — sync may have failed`);
+    }
+  }
+
+  console.log(`\n✅ Sync complete: lu:${skillName} → ~/.config/opencode/skills/${skillName}/`);
+  console.log(`\nNext: node ~/.config/opencode/skills/create-skill/scripts/validate.cjs ${skillName}`);
+} catch (err) {
+  console.error(`❌ Sync failed: ${err.message}`);
+  process.exit(1);
+}

package/agentic/opencode/.opencode/skills/create-skill/scripts/validate.cjs

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+/**
+ * validate.cjs — Validate Luna skill structure and hardlink integrity
+ *
+ * Usage:
+ *   node validate.cjs <skill-name>
+ *
+ * Checks:
+ *   - SKILL.md exists with valid YAML frontmatter
+ *   - name starts with "lu:"
+ *   - description < 200 chars
+ *   - SKILL.md body <= 150 lines
+ *   - Hardlink integrity: ~/.config/opencode/skills/<name>/ files share same inode
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const skillName = process.argv[2];
+
+if (!skillName) {
+  console.error('Usage: node validate.cjs <skill-name>');
+  process.exit(1);
+}
+
+const cwd = process.cwd();
+const srcRoot = path.join(cwd, '.agents', 'skills', skillName);
+const destRoot = path.join(os.homedir(), '.config', 'opencode', 'skills', skillName);
+
+let errors = 0;
+let warnings = 0;
+
+function pass(msg) { console.log(`  ✅ ${msg}`); }
+function fail(msg) { console.log(`  ❌ ${msg}`); errors++; }
+function warn(msg) { console.log(`  ⚠️  ${msg}`); warnings++; }
+
+// --- Check source exists ---
+console.log(`\n🔍 Validating lu:${skillName}\n`);
+
+if (!fs.existsSync(srcRoot)) {
+  console.error(`❌ Skill not found: ${srcRoot}`);
+  process.exit(1);
+}
+pass(`Source dir: agentic/opencode/.opencode/skills/${skillName}/`);
+
+// --- Parse SKILL.md frontmatter ---
+const skillMdPath = path.join(srcRoot, 'SKILL.md');
+if (!fs.existsSync(skillMdPath)) {
+  fail('SKILL.md missing');
+  process.exit(1);
+}
+
+const content = fs.readFileSync(skillMdPath, 'utf8');
+const lines = content.split('\n');
+pass(`SKILL.md exists (${lines.length} lines)`);
+
+// Line count check
+if (lines.length > 150) {
+  warn(`SKILL.md is ${lines.length} lines (recommended: ≤150). Move details to references/.`);
+} else {
+  pass(`Line count: ${lines.length} ≤ 150`);
+}
+
+// Parse YAML frontmatter
+const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+if (!fmMatch) {
+  fail('Missing YAML frontmatter (--- block)');
+} else {
+  const fm = fmMatch[1];
+
+  // name field
+  const nameMatch = fm.match(/^name:\s*(.+)$/m);
+  if (!nameMatch) {
+    fail('Frontmatter missing "name" field');
+  } else {
+    const name = nameMatch[1].trim().replace(/['"]/g, '');
+    if (!name.startsWith('lu:')) {
+      fail(`name must start with "lu:" — found: "${name}"`);
+    } else {
+      pass(`name: ${name}`);
+    }
+  }
+
+  // description field
+  const descMatch = fm.match(/^description:\s*(.+)$/m);
+  if (!descMatch) {
+    fail('Frontmatter missing "description" field');
+  } else {
+    const desc = descMatch[1].trim().replace(/^['"]|['"]$/g, '');
+    if (desc.includes('TODO')) {
+      warn('description still contains TODO placeholder');
+    } else if (desc.length > 200) {
+      fail(`description too long: ${desc.length} chars (max 200)`);
+    } else {
+      pass(`description: ${desc.length} chars ≤ 200`);
+    }
+  }
+
+  // author field (optional but recommended)
+  if (!fm.includes('author:')) {
+    warn('Frontmatter missing "author" field (recommended: author: luna)');
+  } else {
+    pass('author field present');
+  }
+}
+
+// --- Check for TODO placeholders in body ---
+const todoCount = (content.match(/\[TODO:/g) || []).length;
+if (todoCount > 0) {
+  warn(`${todoCount} TODO placeholder(s) still in SKILL.md`);
+}
+
+// --- Hardlink integrity check ---
+console.log(`\n  Checking hardlinks → ~/.config/opencode/skills/${skillName}/\n`);
+
+if (!fs.existsSync(destRoot)) {
+  fail(`~/.config/opencode/skills/${skillName}/ not found — run sync.cjs first`);
+} else {
+  // Walk source and verify each file is hardlinked
+  function checkLinks(srcDir, destDir) {
+    const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const srcPath = path.join(srcDir, entry.name);
+      const destPath = path.join(destDir, entry.name);
+      if (entry.isDirectory()) {
+        if (fs.existsSync(destPath)) checkLinks(srcPath, destPath);
+        else warn(`Directory not synced: ${path.relative(srcRoot, srcPath)}/`);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (!fs.existsSync(destPath)) {
+        fail(`Not synced: ${path.relative(srcRoot, srcPath)}`);
+        continue;
+      }
+      const s = fs.statSync(srcPath);
+      const d = fs.statSync(destPath);
+      if (s.ino === d.ino) {
+        pass(`Hardlinked: ${path.relative(srcRoot, srcPath)} (inode ${s.ino})`);
+      } else {
+        fail(`Inode mismatch: ${path.relative(srcRoot, srcPath)} — re-run sync.cjs`);
+      }
+    }
+  }
+  checkLinks(srcRoot, destRoot);
+}
+
+// --- Summary ---
+console.log(`\n${'─'.repeat(50)}`);
+if (errors === 0 && warnings === 0) {
+  console.log(`✅ All checks passed — lu:${skillName} is valid`);
+} else if (errors === 0) {
+  console.log(`✅ Valid with ${warnings} warning(s) — lu:${skillName}`);
+} else {
+  console.log(`❌ ${errors} error(s), ${warnings} warning(s) — fix before using`);
+  process.exit(1);
+}

package/agentic/opencode/.opencode/skills/debugger/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: lu:debugger
+author: luna
+description: "Debug systematically with root cause analysis before fixes. Use for bugs, test failures, unexpected behavior, performance issues, call stack tracing, multi-layer validation, log analysis, CI/CD failures, database diagnostics, system investigation."
+version: 1.0.0
+argument-hint: "[error or issue description]"
+---
+
+# Debugging & System Investigation
+
+Comprehensive framework combining systematic debugging, root cause tracing, defense-in-depth validation, verification protocols, and system-level investigation (logs, CI/CD, databases, performance).
+
+## Core Principle
+
+**NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST**
+
+Random fixes waste time and create new bugs. Find root cause, fix at source, validate at every layer, verify before claiming success.
+
+## When to Use
+
+**Code-level:** Test failures, bugs, unexpected behavior, build failures, integration problems
+**System-level:** Server errors, CI/CD pipeline failures, performance degradation, database issues, log analysis
+**Always:** Before claiming work complete
+
+## Techniques
+
+### 1. Systematic Debugging (`references/systematic-debugging.md`)
+
+Four-phase framework: Root Cause Investigation → Pattern Analysis → Hypothesis Testing → Implementation. Complete each phase before proceeding. No fixes without Phase 1.
+
+**Load when:** Any bug/issue requiring investigation and fix
+
+### 2. Root Cause Tracing (`references/root-cause-tracing.md`)
+
+Trace bugs backward through call stack to find original trigger. Fix at source, not symptom. Includes `scripts/find-polluter.sh` for bisecting test pollution.
+
+**Load when:** Error deep in call stack, unclear where invalid data originated
+
+### 3. Defense-in-Depth (`references/defense-in-depth.md`)
+
+Validate at every layer: Entry validation → Business logic → Environment guards → Debug instrumentation
+
+**Load when:** After finding root cause, need comprehensive validation
+
+### 4. Verification (`references/verification.md`)
+
+**Iron law:** NO COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE. Run command. Read output. Then claim result.
+
+**Load when:** About to claim work complete, fixed, or passing
+
+### 5. Investigation Methodology (`references/investigation-methodology.md`)
+
+Five-step structured investigation for system-level issues: Initial Assessment → Data Collection → Analysis → Root Cause ID → Solution Development
+
+**Load when:** Server incidents, system behavior analysis, multi-component failures
+
+### 6. Log & CI/CD Analysis (`references/log-and-ci-analysis.md`)
+
+Collect and analyze logs from servers, CI/CD pipelines (GitHub Actions), application layers. Tools: `gh` CLI, structured log queries, correlation across sources.
+
+**Load when:** CI/CD pipeline failures, server errors, deployment issues
+
+### 7. Performance Diagnostics (`references/performance-diagnostics.md`)
+
+Identify bottlenecks, analyze query performance, develop optimization strategies. Covers database queries, API response times, resource utilization.
+
+**Load when:** Performance degradation, slow queries, high latency, resource exhaustion
+
+### 8. Reporting Standards (`references/reporting-standards.md`)
+
+Structured diagnostic reports: Executive Summary → Technical Analysis → Recommendations → Evidence
+
+**Load when:** Need to produce investigation report or diagnostic summary
+
+### 9. Task Management (`references/task-management-debugging.md`)
+
+Track investigation pipelines via Claude Native Tasks (TaskCreate, TaskUpdate, TaskList). Hydration pattern for multi-step investigations with dependency chains and parallel evidence collection.
+
+**Load when:** Multi-component investigation (3+ steps), parallel log collection, coordinating debugger subagents
+
+### 10. Frontend Verification (`references/frontend-verification.md`)
+
+Visual verification of frontend implementations via Chrome MCP (Claude Chrome Extension) or browser automation fallback. Detect if frontend-related → check Chrome MCP availability → screenshot + console error check → report. Skip if not frontend.
+
+**Load when:** Implementation touches frontend files (tsx/jsx/vue/svelte/html/css), UI bugs, visual regressions
+
+## Quick Reference
+
+```
+Code bug       → systematic-debugging.md (Phase 1-4)
+  Deep in stack  → root-cause-tracing.md (trace backward)
+  Found cause    → defense-in-depth.md (add layers)
+  Claiming done  → verification.md (verify first)
+
+System issue   → investigation-methodology.md (5 steps)
+  CI/CD failure  → log-and-ci-analysis.md
+  Slow system    → performance-diagnostics.md
+  Need report    → reporting-standards.md
+
+Frontend fix   → frontend-verification.md (Chrome MCP/devtools)
+```
+
+## Tools Integration
+
+- **Codebase scouting:** `scout` skill for finding relevant files
+- **Research:** `research` skill for deep codebase exploration
+- **Database:** `psql` for PostgreSQL queries and diagnostics
+- **CI/CD:** `gh` CLI for GitHub Actions logs and pipeline debugging
+- **Frontend:** Chrome MCP or browser automation for visual verification
+
+## Red Flags
+
+Stop and follow process if thinking:
+- "Quick fix for now, investigate later"
+- "Just try changing X and see if it works"
+- "It's probably X, let me fix that"
+- "Should work now" / "Seems fixed"
+- "Tests pass, we're done"
+
+**All mean:** Return to systematic process.

package/agentic/opencode/.opencode/skills/debugger/references/defense-in-depth.md

@@ -0,0 +1,87 @@
+# Defense-in-Depth Validation
+
+Validate at every layer data passes through to make bugs impossible.
+
+## Core Principle
+
+**Validate at EVERY layer data passes through. Make bug structurally impossible.**
+
+Single check can be bypassed by different code paths, refactoring, or mocks. Multiple layers make the bug impossible.
+
+## The Four Layers
+
+### Layer 1: Entry Point Validation
+**Purpose:** Reject obviously invalid input at API boundary
+
+```typescript
+function createProject(name: string, workingDirectory: string) {
+  if (!workingDirectory || workingDirectory.trim() === '') {
+    throw new Error('workingDirectory cannot be empty');
+  }
+  if (!existsSync(workingDirectory)) {
+    throw new Error(`workingDirectory does not exist: ${workingDirectory}`);
+  }
+  // proceed
+}
+```
+
+### Layer 2: Business Logic Validation
+**Purpose:** Ensure data makes sense for this operation
+
+```typescript
+function initializeWorkspace(projectDir: string, sessionId: string) {
+  if (!projectDir) {
+    throw new Error('projectDir required for workspace initialization');
+  }
+  // proceed
+}
+```
+
+### Layer 3: Environment Guards
+**Purpose:** Prevent dangerous operations in specific contexts
+
+```typescript
+async function gitInit(directory: string) {
+  if (process.env.NODE_ENV === 'test') {
+    const normalized = normalize(resolve(directory));
+    const tmpDir = normalize(resolve(tmpdir()));
+    if (!normalized.startsWith(tmpDir)) {
+      throw new Error(`Refusing git init outside temp dir: ${directory}`);
+    }
+  }
+  // proceed
+}
+```
+
+### Layer 4: Debug Instrumentation
+**Purpose:** Capture context for forensics
+
+```typescript
+async function gitInit(directory: string) {
+  logger.debug('About to git init', {
+    directory,
+    cwd: process.cwd(),
+    stack: new Error().stack,
+  });
+  // proceed
+}
+```
+
+## Applying the Pattern
+
+When find bug:
+
+1. **Trace data flow** — Where does bad value originate? Where used?
+2. **Map all checkpoints** — List every point data passes through
+3. **Add validation at each layer** — Entry, business, environment, debug
+4. **Test each layer** — Try to bypass layer 1, verify layer 2 catches it
+
+## Key Insight
+
+All four layers are necessary. During testing, each layer catches bugs others miss:
+- Different code paths bypass entry validation
+- Mocks bypass business logic checks
+- Edge cases on different platforms need environment guards
+- Debug logging identifies structural misuse
+
+**Don't stop at one validation point.** Add checks at every layer.

package/agentic/opencode/.opencode/skills/debugger/references/frontend-verification.md

@@ -0,0 +1,70 @@
+# Frontend Verification
+
+Visual verification of frontend implementations using Chrome MCP or browser automation fallback.
+
+## Applicability Check
+
+**Skip entirely if task is NOT frontend-related.** Frontend indicators:
+- Files modified: `*.tsx`, `*.jsx`, `*.vue`, `*.svelte`, `*.html`, `*.css`, `*.scss`
+- Changes to: components, layouts, pages, styles, DOM structure, UI behavior
+- Keywords: render, display, layout, responsive, animation, visual, UI, UX
+
+If none match, skip this technique.
+
+## Step 1: Detect Chrome MCP Availability
+
+Check if Chrome MCP server is available:
+
+```
+Use ListMcpResourcesTool to check for Chrome MCP tools.
+Look for tools prefixed with "chrome__" (e.g., chrome__navigate, chrome__screenshot).
+```
+
+**Available** → Proceed to Step 2A (Chrome MCP)
+**Not available** → Proceed to Step 2B (manual/devtools fallback)
+
+## Step 2A: Chrome MCP Available
+
+Ensure dev server is running first.
+
+### Navigate & Screenshot
+```
+1. chrome__navigate → http://localhost:3000 (or project dev URL)
+2. chrome__screenshot → capture current page state
+3. Read the screenshot to visually inspect
+```
+
+### Visual Inspection Checklist
+1. **Layout** — Elements positioned correctly, no overflow/overlap
+2. **Content** — Text, images, data rendered as expected
+3. **Interactions** — Use chrome__click / chrome__type to test interactive elements
+4. **Console errors** — Use chrome__evaluate: `JSON.stringify(window.__consoleErrors || [])`
+
+## Step 2B: Chrome MCP NOT Available
+
+Options in priority order:
+1. Ask user to check browser console and share screenshots
+2. Use `ui-ux-pro-max` skill for UI/UX review of code changes
+3. Note in report: "Visual verification skipped — no Chrome MCP available."
+
+## Step 3: Analyze Results
+
+1. **Check console output** — Zero errors = pass; errors = investigate
+2. **Compare with expected** — Match against design specs or user description
+3. **Document findings** — Include screenshot path and issues found
+
+## Integration with Verification Protocol
+
+Extends `verification.md`. After standard verification, add frontend verification as final gate:
+
+```
+Tests pass → Build succeeds → Frontend visual verification → Claim complete
+```
+
+Report format:
+```
+## Frontend Verification
+- Method: [Chrome MCP | manual | skipped]
+- Console errors: [none | list]
+- Visual check: [pass | issues found]
+```

package/agentic/opencode/.opencode/skills/debugger/references/investigation-methodology.md

@@ -0,0 +1,98 @@
+# Investigation Methodology
+
+Five-step structured investigation for system-level issues, incidents, and multi-component failures.
+
+## When to Use
+
+- Server returning 500 errors or unexpected responses
+- System behavior changed without obvious code changes
+- Multi-component failures spanning services/databases/infrastructure
+- Need to understand "what happened" before fixing
+
+## Step 1: Initial Assessment
+
+**Gather scope and impact before diving in.**
+
+1. **Collect symptoms** — Error messages, affected endpoints, user reports
+2. **Identify affected components** — Which services, databases, queues involved?
+3. **Determine timeframe** — When did issue start? Correlate with deployments/changes
+4. **Assess severity** — Users affected? Data at risk? Revenue impact?
+5. **Check recent changes** — Git log, deployment history, config changes
+
+```bash
+# Recent deployments
+gh run list --limit 10
+# Recent commits
+git log --oneline -20 --since="2 days ago"
+# Config changes
+git diff HEAD~5 -- '*.env*' '*.config*' '*.yml' '*.yaml' '*.json'
+```
+
+## Step 2: Data Collection
+
+**Gather evidence systematically before analysis.**
+
+1. **Server/application logs** — Filter by timeframe and affected components
+2. **CI/CD pipeline logs** — Use `gh run view <run-id> --log-failed` for GitHub Actions
+3. **Database state** — Query relevant tables, check recent migrations
+4. **System metrics** — CPU, memory, disk, network utilization
+5. **External dependencies** — Third-party API status, DNS, CDN
+
+```bash
+# GitHub Actions: list recent workflow runs
+gh run list --workflow=<workflow> --limit 5
+# View failed run logs
+gh run view <run-id> --log-failed
+# Download full logs
+gh run view <run-id> --log > /tmp/ci-logs.txt
+```
+
+**For codebase understanding:**
+- Use `scout` skill to find relevant files quickly
+- Use `research` skill for deep codebase exploration
+- Read `STRUCTURE.md` if exists and up-to-date
+
+## Step 3: Analysis Process
+
+**Correlate evidence across sources.**
+
+1. **Timeline reconstruction** — Order events chronologically across all log sources
+2. **Pattern identification** — Recurring errors, timing patterns, affected user segments
+3. **Execution path tracing** — Follow request flow through system components
+4. **Database analysis** — Query performance, table relationships, data integrity
+5. **Dependency mapping** — Which components depend on the failing one?
+
+**Key questions:**
+- Does issue correlate with specific deployments or time windows?
+- Is it intermittent or consistent?
+- Does it affect all users or a subset?
+- Are there related errors in upstream/downstream services?
+
+## Step 4: Root Cause Identification
+
+**Systematic elimination with evidence.**
+
+1. **List hypotheses** ranked by evidence strength
+2. **Test each** — Design smallest experiment to confirm/eliminate
+3. **Validate with evidence** — Logs, metrics, reproduction steps
+4. **Consider environmental factors** — Race conditions, resource limits, config drift
+5. **Document the chain** — Full event sequence from trigger to symptom
+
+**Avoid:** Fixing first hypothesis without testing alternatives.
+
+## Step 5: Solution Development
+
+**Design targeted, evidence-backed fixes.**
+
+1. **Immediate fix** — Minimum change to restore service (hotfix, rollback, config change)
+2. **Root cause fix** — Address underlying issue permanently
+3. **Preventive measures** — Monitoring, alerting, validation to catch recurrence early
+4. **Verification plan** — How to confirm fix works in production
+
+## Integration with Code-Level Debugging
+
+When investigation narrows to specific code:
+- Switch to `systematic-debugging.md` for the code-level fix
+- Use `root-cause-tracing.md` if error is deep in call stack
+- Apply `defense-in-depth.md` after fixing
+- Always finish with `verification.md`