agent-skill-kit 3.9.135

package/.agent/rules/code-rules.md

@@ -0,0 +1,227 @@
+---
+trigger: always_on
+---
+
+# PikaKit — Code & Design Rules
+
+## 📋 TASK LEVEL CLASSIFICATION (STEP 1)
+
+> Classify EVERY request before acting. Default = **L2** if unsure.
+
+| Level | Criteria | Skill Protocol | Example |
+|-------|----------|---------------|--------|
+| **L0** | Question, explain, analyze | ❌ No skill needed | "giải thích hook này", "what is X?" |
+| **L1** | Single-file fix, < 10 lines, obvious intent | ⚡ Identify skill + announce state | "fix typo", "bỏ đường gạch ngang" |
+| **L2** | Multi-file change, logic change | ✅ Read SKILL.md + announce state | "add sparkline to 3 charts" |
+| **L3** | Architecture, new feature, design system | ✅ Full protocol + plan required | "redesign chart system" |
+
+**Classification Rules:**
+- Default = **L2** (safe middle ground)
+- Only L1 if ALL: single file, < 10 lines, zero ambiguity
+- If unsure → L2. If multi-file or design decision → L3
+
+---
+
+## 🤖 INTELLIGENT AGENT ROUTING (STEP 2)
+
+> 📋 **Quick Reference:** Scan `.agent/skills/SKILL_INDEX.md` for skill matching.
+
+1. **Classify** task level (L0-L3) from table above
+2. **Identify** skill(s) from SKILL_INDEX.md
+3. **Execute** protocol for that level:
+
+| Level | Step 1: Identify | Step 2: Read | Step 3: Announce | Step 4: Apply |
+|-------|-----------------|-------------|-----------------|---------------|
+| L0 | — | — | — | — |
+| L1 | ✅ From SKILL_INDEX | ❌ Skip | ✅ Inline State | ⚡ Apply from memory |
+| L2 | ✅ From SKILL_INDEX | ✅ SKILL.md | ✅ State Tree | ✅ Full rules |
+| L3 | ✅ From SKILL_INDEX | ✅ SKILL.md + AGENTS.md | ✅ State Tree | ✅ Full rules + plan |
+
+**Rules:** Silent analysis, professional tone, respect `@skill` overrides.
+
+### ⚡ L1 Protocol (Enforced)
+- Identify skill
+- Announce inline state
+- Apply fix
+- Emit COMPLETED state
+
+**Failure to emit COMPLETED:**
+→ Task considered incomplete
+
+### 📢 NOTIFICATION FORMAT
+
+> See `autopilot.md § 0.5-J` for full branding table (L0–L3 + Workflow).
+
+### ⚠️ AGENT ROUTING CHECKLIST (L2+ ONLY)
+
+> For L2 and L3 tasks, complete this checklist before writing code:
+
+| Step | Check | If Unchecked |
+|------|-------|--------------|
+| 1 | Did I classify the task level? | → STOP. Classify first. |
+| 2 | Did I identify the correct skill from SKILL_INDEX? | → STOP. Scan index. |
+| 3 | Did I read the skill's SKILL.md? | → STOP. Read it. |
+| 4 | Did I output the State Tree? | → STOP. Print state. |
+
+**Enforcement:**
+If any checklist item is skipped:
+→ Response is INVALID
+→ Must restart from Step 1 (Task Classification)
+
+---
+
+## TIER 0: UNIVERSAL RULES (Always Active)
+
+### 🌐 Language Handling
+
+Non-English prompt → translate internally, respond in user's language, code remains English.
+
+### 🧹 Clean Code
+
+ALL code follows `@[skills/code-craft]`: concise, self-documenting, mandatory testing (Unit > Int > E2E), Core Web Vitals, 5-phase deployment.
+
+### 📁 File Dependency Awareness
+
+Before modifying ANY file: check `CODEBASE.md` → identify dependents → update ALL affected files together.
+
+If `CODEBASE.md` is missing or outdated:
+→ Agent MUST infer dependencies from imports/usages
+→ Validate via search before modification
+
+### 🗺️ System Map
+
+> 🔴 Read `ARCHITECTURE.md` at session start.
+
+Skills: `.agent/skills/` | Workflows: `.agent/workflows/` | Scripts: `.agent/scripts/` | Knowledge: `.agent/knowledge/`
+
+### 🧠 Read → Understand → Apply
+
+Before implementation, agent MUST:
+1. Summarize key principle from SKILL.md (1-2 lines)
+2. Apply that principle in code
+
+**Missing summary:**
+→ Indicates shallow execution
+→ Must re-read skill
+
+### 🎓 Knowledge Learning Protocol (MANDATORY)
+
+> 🔴 When user indicates mistake → invoke `@[skills/knowledge-compiler]` Learn operation immediately.
+> Full trigger words, categories, and ID patterns: see `autopilot.md § 0.5-H`.
+
+### 🔄 Continuous Execution Rule (MANDATORY)
+
+User approval = execute ALL phases automatically. No `notify_user` between phases. Only stop for: blocking errors, decision forks, plan completed, explicit user pause.
+
+### 🔒 Execution Mode Lock
+
+When in EXECUTING (Autopilot):
+
+- Agent MUST NOT:
+  → Ask unnecessary questions
+  → Re-enter planning mode
+  → Pause without reason
+
+- Agent MUST:
+  → Continue until completion or blocking condition
+
+**Violation:**
+→ Execution considered interrupted
+→ Must resume from last checkpoint
+
+### 🔍 Problem Verification (MANDATORY)
+
+After ANY task: check `@[current_problems]` → auto-fix (CSS, imports, lint, types) → verify → only notify if can't auto-fix.  
+**Rule:** Don't mark complete until `@[current_problems]` is empty or all non-blocking.
+
+---
+
+## TIER 1: CODE RULES (When Writing Code)
+
+### 📱 Project Type Routing
+
+| Type | Primary Skill | Supporting Skills |
+|------|---------------|-------------------|
+| MOBILE | `mobile-developer` | `mobile-design` |
+| WEB | `react-pro` | `design-system`, `tailwind-kit` |
+| BACKEND | `nodejs-pro` | `api-architect`, `data-modeler` |
+
+> 🔴 Mobile + react-pro = WRONG. Mobile = `mobile-developer` ONLY.
+
+### 🛑 SOCRATIC GATE (Proportional to Task Level)
+
+| Task Level | Strategy |
+|-----------|----------|
+| L0 (Question) | Answer directly |
+| L1 (Quick fix) | Proceed if intent is clear |
+| L2 (Multi-file) | Confirm understanding before starting |
+| L3 (Architecture) | ASK 1-3 strategic questions, then plan |
+| Vague / Ambiguous | Ask Purpose + Scope before classifying |
+
+**Never Assume.** Reference: `@[skills/idea-storm]` for complex requirements.
+
+### 🏁 Final Checklist
+
+| Stage | Command |
+|-------|---------|
+| Development | `npm run checklist` |
+| Pre-Deploy | `npm run verify <URL>` |
+
+**Order:** Security → Lint → Schema → Tests → UX → SEO → Lighthouse/E2E
+
+### 🎭 Gemini Mode Mapping
+
+| Mode | Agent | Behavior |
+|------|-------|----------|
+| **plan** | `project-planner` | 4-phase: Analysis → Planning → Solutioning → Implementation |
+| **ask** | - | Focus on understanding |
+| **edit** | `orchestrator` | Check `{task-slug}.md` first. Multi-file → offer plan. Single-file → proceed. |
+
+---
+
+## TIER 2: DESIGN RULES (Reference)
+
+Design rules are in specialist agents, NOT here.
+
+| Task | Read |
+|------|------|
+| Web UI/UX | `.agent/skills/react-pro/AGENTS.md` |
+| Mobile UI/UX | `.agent/skills/mobile-developer/AGENTS.md` |
+
+---
+
+## 📜 Scripts & Quick Reference
+
+**Master Scripts:** `checklist.ts` (dev), `verify_all.ts` (deploy), `auto_preview.ts`, `session_manager.ts`, `autopilot-runner.js`, `autopilot-metrics.js`, `preflight-assessment.js`, `adaptive-workflow.js`, `metrics-dashboard.js`, `skill-validator.js`
+
+**Usage:** `npm run checklist` (dev) | `npm run verify http://localhost:3000` (deploy)
+
+> Agents & Skills can invoke scripts via `python .agent/skills/<skill>/scripts/<script>.py`
+
+### Quick Skill Reference
+
+| Need | Primary Skill | Supporting Skills |
+|------|---------------|-------------------|
+| Web App | `react-pro` | `nextjs-pro`, `design-system` |
+| API | `nodejs-pro` | `api-architect`, `auth-patterns` |
+| Mobile | `mobile-developer` | `mobile-design` |
+| Database | `data-modeler` | `nodejs-pro` |
+| Security | `security-scanner` | `offensive-sec`, `auth-patterns` |
+| Testing | `test-architect` | `e2e-automation` |
+| Debug | `debug-pro` | `problem-checker` |
+| Plan | `project-planner` | `idea-storm`, `system-design` |
+| Knowledge | `knowledge-compiler` | `knowledge-linter`, `skill-generator` |
+
+---
+
+## 📊 Statistics
+
+| Metric | Value |
+|--------|-------|
+| **Total Agents** | 21 (16 domain + 5 meta) |
+| **Total Skills** | 51 |
+| **Total Workflows** | 19 |
+| **Total Scripts** | 6 |
+| **Coverage** | ~95% web/mobile development |
+
+---

package/.agent/scripts/audit_workflows.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+/**
+ * Audit Workflows - PikaKit
+ * Checks workflow files for FAANG compliance.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+const dir = 'C:/Users/sofma/Desktop/agent-skill-kit/.agent/workflows';
+const files = fs.readdirSync(dir).filter((f: string) => f.endsWith('.md'));
+
+for (const f of files) {
+    const txt = fs.readFileSync(path.join(dir, f), 'utf8');
+    const issues: string[] = [];
+    if (!/^skills:/m.test(txt)) issues.push('Missing skills in YAML');
+    if (!/^agents:/m.test(txt)) issues.push('Missing agents in YAML');
+    if (!/auto-learned|Auto-Learned/i.test(txt)) issues.push('Missing Auto-Learned Pattern check');
+    if (!/Exit Gate|Problem Verification|@\[current_problems\]/i.test(txt)) issues.push('Missing Exit Gates');
+    if (!/Rollback/i.test(txt)) issues.push('Missing Rollback section');
+    if (issues.length) console.log('❌ ' + f + ' -> ' + issues.join(', '));
+    else console.log('✅ ' + f + ' -> FAANG compliant!');
+}

package/.agent/scripts/auto_preview.ts

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+
+/**
+ * Auto Preview - PikaKit
+ * ===============================
+ * Development server manager (start/stop/status)
+ *
+ * Usage:
+ *   npx tsx auto_preview.ts start [port]
+ *   npx tsx auto_preview.ts stop
+ *   npx tsx auto_preview.ts status
+ */
+
+import { readFile } from 'fs/promises';
+import { join, resolve } from 'path';
+import { spawn } from 'child_process';
+import { createWriteStream } from 'fs';
+import { parseArgs } from 'node:util';
+import { savePid, loadPid, deletePidFile, isRunning, killProcessTree } from './utils/process-manager.ts';
+
+const AGENT_DIR = resolve(process.cwd(), '.agent');
+const PID_FILE = join(AGENT_DIR, 'preview.pid');
+const LOG_FILE = join(AGENT_DIR, 'preview.log');
+
+interface PackageJson {
+    scripts?: Record<string, string>;
+}
+
+/**
+ * Get start command from package.json
+ */
+async function getStartCommand(root: string): Promise<string[] | null> {
+    const pkgFile = join(root, 'package.json');
+
+    try {
+        const data: PackageJson = JSON.parse(await readFile(pkgFile, 'utf-8'));
+        const scripts = data.scripts || {};
+
+        if (scripts.dev) {
+            return ['npm', 'run', 'dev'];
+        } else if (scripts.start) {
+            return ['npm', 'start'];
+        }
+        return null;
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Start development server
+ */
+async function startServer(port: number = 3000): Promise<void> {
+    // Check if already running
+    const existingPid = await loadPid(PID_FILE);
+    if (existingPid && isRunning(existingPid)) {
+        console.log(`⚠️  Preview already running (PID: ${existingPid})`);
+        return;
+    }
+
+    const root = process.cwd();
+    const cmd = await getStartCommand(root);
+
+    if (!cmd) {
+        console.log('❌ No \'dev\' or \'start\' script found in package.json');
+        process.exit(1);
+    }
+
+    console.log(`🚀 Starting preview on port ${port}...`);
+
+    // Prepare log file
+    const logStream = createWriteStream(LOG_FILE, { flags: 'w' });
+
+    // Spawn detached process
+    const child = spawn(cmd[0], cmd.slice(1), {
+        detached: true,
+        stdio: ['ignore', logStream, logStream],
+        env: { ...process.env, PORT: port.toString() },
+        cwd: root,
+        shell: true
+    });
+
+    // Allow parent to exit
+    child.unref();
+
+    if (child.pid) {
+        await savePid(PID_FILE, child.pid);
+        console.log(`✅ Preview started! (PID: ${child.pid})`);
+    }
+    console.log(`   Logs: ${LOG_FILE}`);
+    console.log(`   URL: http://localhost:${port}`);
+}
+
+/**
+ * Stop development server
+ */
+async function stopServer(): Promise<void> {
+    const pid = await loadPid(PID_FILE);
+
+    if (!pid) {
+        console.log('ℹ️  No preview server found.');
+        return;
+    }
+
+    if (!isRunning(pid)) {
+        console.log('ℹ️  Process was not running.');
+        await deletePidFile(PID_FILE);
+        return;
+    }
+
+    try {
+        await killProcessTree(pid);
+        console.log(`🛑 Preview stopped (PID: ${pid})`);
+    } catch (err: unknown) {
+        console.log(`❌ Error stopping server: ${err instanceof Error ? err.message : String(err)}`);
+    } finally {
+        await deletePidFile(PID_FILE);
+    }
+}
+
+/**
+ * Show server status
+ */
+async function statusServer(): Promise<void> {
+    const pid = await loadPid(PID_FILE);
+    const running = pid && isRunning(pid);
+
+    console.log('\n=== Preview Status ===');
+
+    if (running) {
+        console.log('✅ Status: Running');
+        console.log(`🔢 PID: ${pid}`);
+        console.log('🌐 URL: http://localhost:3000 (Likely)');
+        console.log(`📝 Logs: ${LOG_FILE}`);
+    } else {
+        console.log('⚪ Status: Stopped');
+    }
+
+    console.log('===================\n');
+}
+
+/**
+ * Main entry point
+ */
+async function main(): Promise<void> {
+    const { positionals } = parseArgs({
+        args: process.argv.slice(2),
+        allowPositionals: true,
+        options: {}
+    });
+
+    const action = positionals[0];
+    const port = positionals[1] || '3000';
+
+    if (action === 'start') {
+        await startServer(parseInt(port, 10));
+    } else if (action === 'stop') {
+        await stopServer();
+    } else if (action === 'status') {
+        await statusServer();
+    } else {
+        console.error('Usage: npx tsx auto_preview.ts [start|stop|status] [port]');
+        process.exit(1);
+    }
+}
+
+main().catch(err => {
+    console.error('Error:', err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});

package/.agent/scripts/checklist.ts

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+
+/**
+ * Checklist - PikaKit Master Validator
+ * =============================================
+ * Priority-based validation orchestrator
+ *
+ * Usage:
+ *   npx tsx checklist.ts <project>
+ *   npx tsx checklist.ts <project> --url <URL>
+ *   npx tsx checklist.ts <project> --format json
+ */
+
+import { resolve, join } from 'path';
+import { parseArgs } from 'node:util';
+import { access } from 'fs/promises';
+import { printHeader, printStep, printSuccess, printWarning, printError } from './utils/colors.ts';
+import { runScript, scriptExists, type ScriptResult } from './utils/runner.ts';
+import { formatJsonOutput, printSummary, type CheckResult } from './utils/reporter.ts';
+
+interface CheckConfig {
+    name: string;
+    script: string;
+    required: boolean;
+}
+
+// Define priority-ordered checks
+const CORE_CHECKS: CheckConfig[] = [
+    { name: 'Security Scan', script: '.agent/skills/security-scanner/scripts/security_scan.ts', required: true },
+    { name: 'Lint Check', script: '.agent/skills/code-review/scripts/lint_runner.ts', required: true },
+    { name: 'Schema Validation', script: '.agent/skills/data-modeler/scripts/schema_validator.ts', required: false },
+    { name: 'Test Runner', script: '.agent/skills/test-architect/scripts/test_runner.ts', required: false },
+    { name: 'UX Audit', script: '.agent/skills/design-system/scripts/ux_audit.ts', required: false },
+    { name: 'SEO Check', script: '.agent/skills/seo-optimizer/scripts/seo_checker.ts', required: false }
+];
+
+const PERFORMANCE_CHECKS: CheckConfig[] = [
+    { name: 'Lighthouse Audit', script: '.agent/skills/perf-optimizer/scripts/lighthouse_audit.ts', required: true },
+    { name: 'Playwright E2E', script: '.agent/skills/e2e-automation/scripts/playwright_runner.ts', required: false }
+];
+
+/**
+ * Run a single validation script
+ */
+async function runCheck(name: string, scriptPath: string, projectPath: string, url: string | null = null): Promise<CheckResult> {
+    const fullPath = join(projectPath, scriptPath);
+
+    // Check if script exists
+    if (!(await scriptExists(fullPath))) {
+        printWarning(`${name}: Script not found, skipping`);
+        return { name, passed: true, skipped: true, duration: 0 };
+    }
+
+    printStep(`Running: ${name}`);
+    const startTime = Date.now();
+
+    try {
+        // Build args
+        const args: string[] = [projectPath];
+        if (url && (scriptPath.includes('lighthouse') || scriptPath.includes('playwright'))) {
+            args.push(url);
+        }
+
+        const result: ScriptResult = await runScript(fullPath, args, {
+            timeout: 300000, // 5 minutes
+            cwd: projectPath
+        });
+
+        const duration = (Date.now() - startTime) / 1000;
+
+        if (result.passed) {
+            printSuccess(`${name}: PASSED`);
+        } else {
+            printError(`${name}: FAILED`);
+            if (result.stderr) {
+                console.log(`  Error: ${result.stderr.substring(0, 200)}`);
+            }
+        }
+
+        return {
+            name,
+            passed: result.passed,
+            output: result.stdout,
+            error: result.stderr,
+            skipped: false,
+            duration
+        };
+
+    } catch (err: unknown) {
+        const duration = (Date.now() - startTime) / 1000;
+        const message = err instanceof Error ? err.message : String(err);
+
+        if (message.includes('Timeout')) {
+            printError(`${name}: TIMEOUT (>5 minutes)`);
+            return { name, passed: false, skipped: false, duration, error: 'Timeout' };
+        } else {
+            printError(`${name}: ERROR - ${message}`);
+            return { name, passed: false, skipped: false, duration, error: message };
+        }
+    }
+}
+
+/**
+ * Main entry point
+ */
+async function main(): Promise<void> {
+    const { values, positionals } = parseArgs({
+        args: process.argv.slice(2),
+        allowPositionals: true,
+        options: {
+            url: { type: 'string' },
+            'skip-performance': { type: 'boolean', default: false },
+            format: { type: 'string', default: 'text' },
+            verbose: { type: 'boolean', short: 'v', default: false }
+        }
+    });
+
+    const projectPath = resolve(positionals[0] || '.');
+
+    // Check if project exists
+    try {
+        await access(projectPath);
+    } catch {
+        printError(`Project path does not exist: ${projectPath}`);
+        process.exit(1);
+    }
+
+    const startTime = new Date();
+
+    if (values.format === 'text') {
+        printHeader('🚀 PikaKit - MASTER CHECKLIST');
+    }
+
+    console.log(`Project: ${projectPath}`);
+    console.log(`URL: ${values.url || 'Not provided (performance checks skipped)'}`);
+
+    const results: CheckResult[] = [];
+
+    // Run core checks
+    if (values.format === 'text') {
+        printHeader('📋 CORE CHECKS');
+    }
+
+    for (const check of CORE_CHECKS) {
+        const result = await runCheck(check.name, check.script, projectPath);
+        results.push(result);
+
+        // If required check fails, stop
+        if (check.required && !result.passed && !result.skipped) {
+            printError(`CRITICAL: ${check.name} failed. Stopping checklist.`);
+            printSummary(results);
+            process.exit(1);
+        }
+    }
+
+    // Run performance checks if URL provided
+    if (values.url && !values['skip-performance']) {
+        if (values.format === 'text') {
+            printHeader('⚡ PERFORMANCE CHECKS');
+        }
+
+        for (const check of PERFORMANCE_CHECKS) {
+            const result = await runCheck(check.name, check.script, projectPath, values.url);
+            results.push(result);
+        }
+    }
+
+    // Print summary
+    if (values.format === 'json') {
+        console.log(formatJsonOutput(results, projectPath, values.url ?? null, startTime));
+    }
+
+    const allPassed = printSummary(results);
+    process.exit(allPassed ? 0 : 1);
+}
+
+main().catch(err => {
+    console.error('Error:', err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});