vibelearn 0.1.1

package/plugin/scripts/worker-wrapper.cjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+"use strict";var m=Object.create;var w=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var I=Object.getOwnPropertyNames;var f=Object.getPrototypeOf,x=Object.prototype.hasOwnProperty;var g=(e,i,n,o)=>{if(i&&typeof i=="object"||typeof i=="function")for(let s of I(i))!x.call(e,s)&&s!==n&&w(e,s,{get:()=>i[s],enumerable:!(o=u(i,s))||o.enumerable});return e};var k=(e,i,n)=>(n=e!=null?m(f(e)):{},g(i||!e||!e.__esModule?w(n,"default",{value:e,enumerable:!0}):n,e));var c=require("child_process"),p=k(require("path"),1),y=process.platform==="win32",P=__dirname,l=p.default.join(P,"worker-service.cjs"),t=null,a=!1;function r(e){let i=new Date().toISOString();console.log(`[${i}] [wrapper] ${e}`)}function h(){r(`Spawning inner worker: ${l}`),t=(0,c.spawn)(process.execPath,[l],{stdio:["inherit","inherit","inherit","ipc"],env:{...process.env,VIBELEARN_MANAGED:"true"},cwd:p.default.dirname(l)}),t.on("message",async e=>{(e.type==="restart"||e.type==="shutdown")&&(r(`${e.type} requested by inner`),a=!0,await d(),r("Exiting wrapper"),process.exit(0))}),t.on("exit",(e,i)=>{r(`Inner exited with code=${e}, signal=${i}`),t=null,a||(r("Inner exited unexpectedly, wrapper exiting (hooks will restart if needed)"),process.exit(e??0))}),t.on("error",e=>{r(`Inner error: ${e.message}`)})}async function d(){if(!t||!t.pid){r("No inner process to kill");return}let e=t.pid;if(r(`Killing inner process tree (pid=${e})`),y)try{(0,c.execSync)(`taskkill /PID ${e} /T /F`,{timeout:1e4,stdio:"ignore"}),r(`taskkill completed for pid=${e}`)}catch(i){r(`taskkill failed (process may be dead): ${i}`)}else{t.kill("SIGTERM");let i=new Promise(o=>{if(!t){o();return}t.on("exit",()=>o())}),n=new Promise(o=>setTimeout(()=>o(),5e3));await Promise.race([i,n]),t&&!t.killed&&(r("Inner did not exit gracefully, force killing"),t.kill("SIGKILL"))}await S(e,5e3),t=null,r("Inner process terminated")}async function S(e,i){let n=Date.now();for(;Date.now()-n<i;)try{process.kill(e,0),await new Promise(o=>setTimeout(o,100))}catch{return}r(`Timeout waiting for process ${e} to exit`)}process.on("SIGTERM",async()=>{r("Wrapper received SIGTERM"),a=!0,await d(),process.exit(0)});process.on("SIGINT",async()=>{r("Wrapper received SIGINT"),a=!0,await d(),process.exit(0)});r("Wrapper starting");h();

package/plugin/skills/smart-explore/SKILL.md

@@ -0,0 +1,145 @@
+---
+name: smart-explore
+description: Token-optimized structural code search using tree-sitter AST parsing. Use instead of reading full files when you need to understand code structure, find functions, or explore a codebase efficiently.
+---
+
+# Smart Explore
+
+Structural code exploration using AST parsing. **This skill overrides your default exploration behavior.** While this skill is active, use smart_search/smart_outline/smart_unfold as your primary tools instead of Read, Grep, and Glob.
+
+**Core principle:** Index first, fetch on demand. Give yourself a map of the code before loading implementation details. The question before every file read should be: "do I need to see all of this, or can I get a structural overview first?" The answer is almost always: get the map.
+
+## Your Next Tool Call
+
+This skill only loads instructions. You must call the MCP tools yourself. Your next action should be one of:
+
+```
+smart_search(query="<topic>", path="./src")    -- discover files + symbols across a directory
+smart_outline(file_path="<file>")              -- structural skeleton of one file
+smart_unfold(file_path="<file>", symbol_name="<name>")  -- full source of one symbol
+```
+
+Do NOT run Grep, Glob, Read, or find to discover files first. `smart_search` walks directories, parses all code files, and returns ranked symbols in one call. It replaces the Glob → Grep → Read discovery cycle.
+
+## 3-Layer Workflow
+
+### Step 1: Search -- Discover Files and Symbols
+
+```
+smart_search(query="shutdown", path="./src", max_results=15)
+```
+
+**Returns:** Ranked symbols with signatures, line numbers, match reasons, plus folded file views (~2-6k tokens)
+
+```
+-- Matching Symbols --
+  function performGracefulShutdown (services/infrastructure/GracefulShutdown.ts:56)
+  function httpShutdown (services/infrastructure/HealthMonitor.ts:92)
+  method WorkerService.shutdown (services/worker-service.ts:846)
+
+-- Folded File Views --
+  services/infrastructure/GracefulShutdown.ts (7 symbols)
+  services/worker-service.ts (12 symbols)
+```
+
+This is your discovery tool. It finds relevant files AND shows their structure. No Glob/find pre-scan needed.
+
+**Parameters:**
+
+- `query` (string, required) -- What to search for (function name, concept, class name)
+- `path` (string) -- Root directory to search (defaults to cwd)
+- `max_results` (number) -- Max matching symbols, default 20, max 50
+- `file_pattern` (string, optional) -- Filter to specific files/paths
+
+### Step 2: Outline -- Get File Structure
+
+```
+smart_outline(file_path="services/worker-service.ts")
+```
+
+**Returns:** Complete structural skeleton -- all functions, classes, methods, properties, imports (~1-2k tokens per file)
+
+**Skip this step** when Step 1's folded file views already provide enough structure. Most useful for files not covered by the search results.
+
+**Parameters:**
+
+- `file_path` (string, required) -- Path to the file
+
+### Step 3: Unfold -- See Implementation
+
+Review symbols from Steps 1-2. Pick the ones you need. Unfold only those:
+
+```
+smart_unfold(file_path="services/worker-service.ts", symbol_name="shutdown")
+```
+
+**Returns:** Full source code of the specified symbol including JSDoc, decorators, and complete implementation (~400-2,100 tokens depending on symbol size). AST node boundaries guarantee completeness regardless of symbol size — unlike Read + agent summarization, which may truncate long methods.
+
+**Parameters:**
+
+- `file_path` (string, required) -- Path to the file (as returned by search/outline)
+- `symbol_name` (string, required) -- Name of the function/class/method to expand
+
+## When to Use Standard Tools Instead
+
+Use these only when smart_* tools are the wrong fit:
+
+- **Grep:** Exact string/regex search ("find all TODO comments", "where is `ensureWorkerStarted` defined?")
+- **Read:** Small files under ~100 lines, non-code files (JSON, markdown, config)
+- **Glob:** File path patterns ("find all test files")
+- **Explore agent:** When you need synthesized understanding across 6+ files, architecture narratives, or answers to open-ended questions like "how does this entire system work end-to-end?" Smart-explore is a scalpel — it answers "where is this?" and "show me that." It doesn't synthesize cross-file data flows, design decisions, or edge cases across an entire feature.
+
+For code files over ~100 lines, prefer smart_outline + smart_unfold over Read.
+
+## Workflow Examples
+
+**Discover how a feature works (cross-cutting):**
+
+```
+1. smart_search(query="shutdown", path="./src")
+   -> 14 symbols across 7 files, full picture in one call
+2. smart_unfold(file_path="services/infrastructure/GracefulShutdown.ts", symbol_name="performGracefulShutdown")
+   -> See the core implementation
+```
+
+**Navigate a large file:**
+
+```
+1. smart_outline(file_path="services/worker-service.ts")
+   -> 1,466 tokens: 12 functions, WorkerService class with 24 members
+2. smart_unfold(file_path="services/worker-service.ts", symbol_name="startSessionProcessor")
+   -> 1,610 tokens: the specific method you need
+Total: ~3,076 tokens vs ~12,000 to Read the full file
+```
+
+**Write documentation about code (hybrid workflow):**
+
+```
+1. smart_search(query="feature name", path="./src")    -- discover all relevant files and symbols
+2. smart_outline on key files                           -- understand structure
+3. smart_unfold on important functions                  -- get implementation details
+4. Read on small config/markdown/plan files             -- get non-code context
+```
+
+Use smart_* tools for code exploration, Read for non-code files. Mix freely.
+
+**Exploration then precision:**
+
+```
+1. smart_search(query="session", path="./src", max_results=10)
+   -> 10 ranked symbols: SessionMetadata, SessionQueueProcessor, SessionSummary...
+2. Pick the relevant one, unfold it
+```
+
+## Token Economics
+
+| Approach | Tokens | Use Case |
+|----------|--------|----------|
+| smart_outline | ~1,000-2,000 | "What's in this file?" |
+| smart_unfold | ~400-2,100 | "Show me this function" |
+| smart_search | ~2,000-6,000 | "Find all X across the codebase" |
+| search + unfold | ~3,000-8,000 | End-to-end: find and read (the primary workflow) |
+| Read (full file) | ~12,000+ | When you truly need everything |
+| Explore agent | ~39,000-59,000 | Cross-file synthesis with narrative |
+
+**4-8x savings** on file understanding (outline + unfold vs Read). **11-18x savings** on codebase exploration vs Explore agent. The narrower the query, the wider the gap — a 27-line function costs 55x less to read via unfold than via an Explore agent, because the agent still reads the entire file.

package/plugin/skills/timeline-report/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: timeline-report
+description: Generate a learning summary report analyzing a project's VibeLearn sessions, concepts, and mastery progress. Use when asked for a learning report, concept summary, or quiz progress overview.
+---
+
+# Learning Summary Report
+
+Generate a comprehensive report of your learning progress from VibeLearn's captured sessions.
+
+## When to Use
+
+Use when users ask for:
+- "Show my learning report"
+- "Summarize what I've learned"
+- "What concepts have I encountered?"
+- "Show my quiz progress"
+- "What are my learning gaps?"
+
+## Workflow
+
+### Step 1: Check Worker Status
+
+```bash
+curl -s http://127.0.0.1:37778/api/health | jq .
+```
+
+If the worker isn't running, prompt the user to start it.
+
+### Step 2: Fetch Learning Data
+
+```bash
+# Developer profile (mastery per concept)
+curl -s http://127.0.0.1:37778/api/vibelearn/profile | jq .
+
+# Pending quiz questions
+curl -s http://127.0.0.1:37778/api/vibelearn/questions/pending | jq .
+```
+
+Or query the database directly for richer data:
+
+```bash
+sqlite3 ~/.vibelearn/vibelearn.db << 'SQL'
+-- Session summary
+SELECT COUNT(*) as sessions FROM vibelearn_session_summaries;
+
+-- Top concept categories
+SELECT category, COUNT(*) as count
+FROM vl_concepts
+GROUP BY category
+ORDER BY count DESC
+LIMIT 10;
+
+-- Mastery overview
+SELECT
+  COUNT(*) as total_concepts,
+  AVG(mastery_score) as avg_mastery,
+  SUM(CASE WHEN mastery_score >= 0.85 THEN 1 ELSE 0 END) as mastered,
+  SUM(CASE WHEN mastery_score < 0.5 THEN 1 ELSE 0 END) as needs_work
+FROM vl_developer_profile;
+
+-- Recent sessions
+SELECT what_was_built, created_at
+FROM vibelearn_session_summaries
+ORDER BY created_at DESC
+LIMIT 5;
+SQL
+```
+
+### Step 3: Generate the Report
+
+Write a report covering:
+
+1. **Sessions Overview** — total sessions analyzed, date range
+2. **Tech Stack** — frameworks and tools detected (from `vl_stack_profiles`)
+3. **Concepts Encountered** — top categories and specific concepts
+4. **Mastery Progress** — how many concepts mastered vs in progress
+5. **Learning Gaps** — concepts with mastery_score < 0.5
+6. **Quiz Stats** — questions answered, correct rate
+
+### Step 4: Recommend Next Actions
+
+Based on the data, suggest:
+- `vl quiz` if pending questions exist
+- `vl gaps` to focus on weak areas
+- `vl login` if not connected to vibelearn.dev
+
+## Notes
+
+- All data is in `~/.vibelearn/vibelearn.db`
+- The `vl` CLI provides interactive access: `vl quiz`, `vl status`, `vl gaps`
+- Worker must be running on port **37778** (not 37777)