promptup-plugin 0.1.1

package/dist/transcript-parser.js

@@ -0,0 +1,201 @@
+/**
+ * Parser for Claude Code JSONL transcript files.
+ *
+ * Fully self-contained — no imports from @promptup/shared or any workspace package.
+ * Reads Claude Code JSONL files and produces MessageRow[] arrays.
+ *
+ * Claude Code JSONL format: each line is a JSON object with a `type` field:
+ *   - "user"     — user prompt  (message.content: string | ContentBlock[])
+ *   - "assistant" — model reply  (message.content: ContentBlock[], message.usage, message.model)
+ *   - "progress" — tool progress (filtered out)
+ *   - "system"   — system event  (filtered out)
+ *   - "result"   — final result  (filtered out)
+ *   - "file_history_snapshot" — file state (filtered out)
+ */
+import { readFileSync, readdirSync, statSync, existsSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { homedir } from 'node:os';
+import { ulid } from 'ulid';
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function isTextBlock(block) {
+    return block.type === 'text' && typeof block.text === 'string';
+}
+function isToolUseBlock(block) {
+    return block.type === 'tool_use' && typeof block.name === 'string';
+}
+/**
+ * Extract human-readable text from a message's content field.
+ */
+function extractText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    const parts = [];
+    for (const block of content) {
+        if (isTextBlock(block)) {
+            parts.push(block.text);
+        }
+        else if (block.type === 'tool_result') {
+            const tr = block;
+            if (typeof tr.content === 'string') {
+                parts.push(`[tool_result] ${tr.content}`);
+            }
+        }
+    }
+    return parts.join('\n');
+}
+/**
+ * Extract tool_use blocks from content, returning a JSON-serializable array.
+ */
+function extractToolUses(content) {
+    if (!Array.isArray(content))
+        return null;
+    const tools = [];
+    for (const block of content) {
+        if (isToolUseBlock(block)) {
+            tools.push({ name: block.name, input: block.input });
+        }
+    }
+    return tools.length > 0 ? JSON.stringify(tools) : null;
+}
+// ─── Main parser ─────────────────────────────────────────────────────────────
+/**
+ * Parse a Claude Code JSONL transcript file into MessageRow[].
+ *
+ * Reads the file, splits by newlines, parses each JSON line, filters to
+ * 'user' and 'assistant' types, extracts text content, tool uses, token
+ * usage, and model name. Assigns 0-indexed sequence numbers and generates
+ * ULID-based IDs.
+ *
+ * Malformed lines are silently skipped.
+ */
+export function parseTranscript(filePath) {
+    const raw = readFileSync(filePath, 'utf-8');
+    const lines = raw.split('\n');
+    const messages = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            const type = parsed.type;
+            if (type !== 'user' && type !== 'assistant')
+                continue;
+            if (!parsed.message || typeof parsed.message !== 'object')
+                continue;
+            messages.push(parsed);
+        }
+        catch {
+            // Skip malformed lines
+        }
+    }
+    // Derive a session ID from the filename (strip .jsonl extension)
+    const sessionId = basename(filePath, '.jsonl');
+    const rows = [];
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        const id = ulid();
+        let role = msg.type;
+        const timestamp = msg.timestamp ?? new Date().toISOString();
+        let content;
+        let toolUses = null;
+        let tokensIn = 0;
+        let tokensOut = 0;
+        let model = null;
+        if (msg.type === 'user') {
+            content = extractText(msg.message.content);
+            // Tool result messages have content blocks that are all tool_result type.
+            // Keep them (they're useful for decision detection) but mark role as 'tool_result'
+            // so the report can distinguish developer prompts from tool outputs.
+            const msgContent = msg.message.content;
+            if (Array.isArray(msgContent) && msgContent.length > 0 && msgContent.every(b => b.type === 'tool_result')) {
+                role = 'tool_result';
+            }
+        }
+        else {
+            // assistant
+            const assistantContent = msg.message.content;
+            content = extractText(assistantContent);
+            toolUses = extractToolUses(assistantContent);
+            if (msg.message.usage) {
+                tokensIn = msg.message.usage.input_tokens ?? 0;
+                tokensOut = msg.message.usage.output_tokens ?? 0;
+            }
+            model = msg.message.model ?? null;
+        }
+        rows.push({
+            id,
+            session_id: sessionId,
+            role,
+            content,
+            tool_uses: toolUses,
+            sequence_number: i,
+            tokens_in: tokensIn,
+            tokens_out: tokensOut,
+            model,
+            created_at: timestamp,
+        });
+    }
+    return rows;
+}
+// ─── Find latest transcript ──────────────────────────────────────────────────
+/**
+ * Find the most recent JSONL transcript file from Claude Code's project directory.
+ * Looks in ~/.claude/projects/ for the most recently modified .jsonl file.
+ *
+ * Walks the directory tree up to 3 levels deep:
+ *   ~/.claude/projects/<project-hash>/sessions/<session-id>.jsonl
+ *
+ * Returns the absolute path to the most recently modified file, or null if none found.
+ */
+export function findLatestTranscript() {
+    const projectsDir = join(homedir(), '.claude', 'projects');
+    if (!existsSync(projectsDir))
+        return null;
+    let latestPath = null;
+    let latestMtime = 0;
+    try {
+        const projectDirs = readdirSync(projectsDir, { withFileTypes: true });
+        for (const projectEntry of projectDirs) {
+            if (!projectEntry.isDirectory())
+                continue;
+            const projectPath = join(projectsDir, projectEntry.name);
+            // Look for .jsonl files directly in the project dir
+            scanForJsonl(projectPath);
+            // Look in a sessions/ subdirectory
+            const sessionsDir = join(projectPath, 'sessions');
+            if (existsSync(sessionsDir)) {
+                scanForJsonl(sessionsDir);
+            }
+        }
+    }
+    catch {
+        // Permissions error or similar — return what we have
+    }
+    function scanForJsonl(dir) {
+        try {
+            const entries = readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isFile() || !entry.name.endsWith('.jsonl'))
+                    continue;
+                const fullPath = join(dir, entry.name);
+                try {
+                    const stat = statSync(fullPath);
+                    if (stat.mtimeMs > latestMtime) {
+                        latestMtime = stat.mtimeMs;
+                        latestPath = fullPath;
+                    }
+                }
+                catch {
+                    // Skip files we can't stat
+                }
+            }
+        }
+        catch {
+            // Skip directories we can't read
+        }
+    }
+    return latestPath;
+}

package/hooks/auto-eval.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+# UserPromptSubmit hook: counts prompts, triggers background eval per config
+PLUGIN_DIR="${CLAUDE_PLUGIN_ROOT:-$HOME/.promptup/plugin}"
+DATA_DIR="${CLAUDE_PLUGIN_DATA:-$HOME/.promptup}"
+COUNT_FILE="$DATA_DIR/prompt-count"
+CONFIG_FILE="$DATA_DIR/config.json"
+
+mkdir -p "$DATA_DIR"
+
+# Read config — check if auto_trigger is enabled
+TRIGGER=$(python3 -c "import json; c=json.load(open('$CONFIG_FILE')); print(c.get('evaluation',{}).get('auto_trigger','off'))" 2>/dev/null || echo "off")
+if [ "$TRIGGER" = "off" ]; then
+  exit 0
+fi
+
+INTERVAL=$(python3 -c "import json; c=json.load(open('$CONFIG_FILE')); print(c.get('evaluation',{}).get('interval',10))" 2>/dev/null || echo "10")
+
+COUNT=$(cat "$COUNT_FILE" 2>/dev/null || echo 0)
+COUNT=$((COUNT + 1))
+echo $COUNT > "$COUNT_FILE"
+
+if [ "$TRIGGER" = "prompt_count" ] && [ "$COUNT" -ge "$INTERVAL" ]; then
+  echo 0 > "$COUNT_FILE"
+  nohup node -e "
+    import { initDatabase, insertSession, insertMessages, getSession } from '$PLUGIN_DIR/dist/db.js';
+    import { parseTranscript, findLatestTranscript } from '$PLUGIN_DIR/dist/transcript-parser.js';
+    import { evaluateSession } from '$PLUGIN_DIR/dist/evaluator.js';
+    import { ulid } from 'ulid';
+    initDatabase();
+    const tp = findLatestTranscript();
+    if (!tp) process.exit(0);
+    const msgs = parseTranscript(tp);
+    if (msgs.length < 3) process.exit(0);
+    const sid = msgs[0]?.session_id || ulid();
+    if (!getSession(sid)) {
+      insertSession({ id: sid, project_path: process.cwd(), transcript_path: tp, status: 'active', message_count: msgs.length, started_at: msgs[0].created_at, ended_at: msgs[msgs.length-1].created_at, created_at: new Date().toISOString() });
+    }
+    for (const m of msgs) m.session_id = sid;
+    insertMessages(msgs);
+    await evaluateSession(sid, msgs, 'prompt_count');
+  " > /dev/null 2>&1 &
+fi
+
+exit 0

package/hooks/check-update.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+# SessionStart hook: checks for plugin update in background
+PLUGIN_DIR="${CLAUDE_PLUGIN_ROOT:-$HOME/.promptup/plugin}"
+DATA_DIR="${CLAUDE_PLUGIN_DATA:-$HOME/.promptup}"
+UPDATE_FILE="$DATA_DIR/update-available"
+
+mkdir -p "$DATA_DIR"
+
+# Get local version
+LOCAL_VER=$(node -e "console.log(require('$PLUGIN_DIR/package.json').version)" 2>/dev/null || echo "0.0.0")
+
+# Check remote version (npm registry)
+REMOTE_VER=$(npm view @promptup/plugin version 2>/dev/null || echo "")
+
+if [ -z "$REMOTE_VER" ]; then
+  # Not published yet or no network — try GitHub
+  REMOTE_VER=$(curl -sf "https://raw.githubusercontent.com/promptup/claude-plugin/main/package.json" 2>/dev/null | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{try{console.log(JSON.parse(d).version)}catch{}})" 2>/dev/null || echo "")
+fi
+
+if [ -n "$REMOTE_VER" ] && [ "$REMOTE_VER" != "$LOCAL_VER" ]; then
+  echo "$REMOTE_VER" > "$UPDATE_FILE"
+else
+  rm -f "$UPDATE_FILE"
+fi
+
+exit 0

package/hooks/debug-hook.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+# Debug: capture PostToolUse input to see the actual format
+cat > ~/.promptup/last-hook-input.json

package/hooks/hooks.json

@@ -0,0 +1,36 @@
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "",
+        "hooks": [{
+          "type": "command",
+          "command": "cat >> \"${CLAUDE_PLUGIN_DATA:-$HOME/.promptup}/tool-events.jsonl\"",
+          "async": true
+        }]
+      },
+      {
+        "matcher": "mcp__promptup__evaluate_session",
+        "hooks": [{
+          "type": "command",
+          "command": "bash \"${CLAUDE_PLUGIN_ROOT:-$HOME/.promptup/plugin}/hooks/render-eval.sh\""
+        }]
+      },
+      {
+        "matcher": "mcp__promptup__generate_pr_report",
+        "hooks": [{
+          "type": "command",
+          "command": "bash \"${CLAUDE_PLUGIN_ROOT:-$HOME/.promptup/plugin}/hooks/render-eval.sh\""
+        }]
+      }
+    ],
+    "Stop": [{
+      "matcher": "",
+      "hooks": [{
+        "type": "command",
+        "command": "cat > \"${CLAUDE_PLUGIN_DATA:-$HOME/.promptup}/session-end.json\"",
+        "async": true
+      }]
+    }]
+  }
+}

package/hooks/render-eval.sh

@@ -0,0 +1,137 @@
+#!/bin/bash
+# PostToolUse hook: renders eval results as a formatted table directly to stderr
+# Triggered after mcp__promptup__evaluate_session completes
+# Reads hook JSON from stdin, extracts the tool output text, renders table
+
+INPUT=$(cat)
+
+# Extract the tool output text from the hook JSON
+# The hook input has: { tool_name, tool_input, tool_output: { content: [{ text: "..." }] } }
+TEXT=$(echo "$INPUT" | jq -r '.tool_output.content[0].text // empty' 2>/dev/null)
+
+if [ -z "$TEXT" ]; then
+  exit 0
+fi
+
+# Parse the markdown table from the eval output and render it with box drawing
+# Extract lines between the table header and the next blank line
+echo "$TEXT" | awk '
+BEGIN {
+  # Colors
+  RED="\033[31m"
+  YEL="\033[33m"
+  GRN="\033[32m"
+  BLD="\033[1m"
+  DIM="\033[2m"
+  RST="\033[0m"
+  found_header=0
+  found_table=0
+}
+
+# Hero composite score line
+/^### Composite Score:/ {
+  gsub(/^### /, "")
+  gsub(/\*\*/, "")
+  printf "\n" > "/dev/stderr"
+  printf " %s%s%s\n", BLD, $0, RST > "/dev/stderr"
+  next
+}
+
+# Progress bar line (emoji squares)
+/^🟩|^🟨|^🟥/ {
+  printf " %s\n", $0 > "/dev/stderr"
+  printf "\n" > "/dev/stderr"
+  next
+}
+
+# Table header
+/^\| Dimension \| Score \| Why \|/ {
+  printf " %s┌───────────────────────────┬──────────────────────────┬────────────────────────────────────────────────────────────────┐%s\n", DIM, RST > "/dev/stderr"
+  printf " %s│ %-25s │ %-24s │ %-62s │%s\n", BLD, "Dimension", "Score", "Why", RST > "/dev/stderr"
+  printf " %s├───────────────────────────┼──────────────────────────┼────────────────────────────────────────────────────────────────┤%s\n", DIM, RST > "/dev/stderr"
+  found_table=1
+  next
+}
+
+# Table separator (skip)
+/^\|---/ { next }
+
+# Table rows
+found_table && /^\|/ {
+  # Split by |
+  n = split($0, cols, "|")
+  if (n >= 4) {
+    dim = cols[2]
+    score_col = cols[3]
+    why = cols[4]
+
+    # Trim whitespace
+    gsub(/^[ \t]+|[ \t]+$/, "", dim)
+    gsub(/^[ \t]+|[ \t]+$/, "", score_col)
+    gsub(/^[ \t]+|[ \t]+$/, "", why)
+
+    # Extract numeric score from score column
+    match(score_col, /[0-9]+/)
+    score = substr(score_col, RSTART, RLENGTH) + 0
+
+    # Color based on score
+    if (score >= 70) color = GRN
+    else if (score >= 40) color = YEL
+    else color = RED
+
+    # Truncate why to fit
+    if (length(why) > 62) why = substr(why, 1, 59) "..."
+
+    printf " │ %-25s │ %s%-24s%s │ %s%-62s%s │\n", dim, color, score_col, RST, DIM, why, RST > "/dev/stderr"
+  }
+  next
+}
+
+# End of table (blank line after table)
+found_table && /^$/ {
+  printf " %s└───────────────────────────┴──────────────────────────┴────────────────────────────────────────────────────────────────┘%s\n", DIM, RST > "/dev/stderr"
+  found_table=0
+  next
+}
+
+# Developer prompts line
+/^Developer prompts:/ {
+  gsub(/\*\*/, "")
+  printf "\n %s%s%s\n", DIM, $0, RST > "/dev/stderr"
+  next
+}
+
+# Decisions header
+/^### Decisions/ {
+  printf "\n %s%sDecisions%s\n", BLD, "", RST > "/dev/stderr"
+  next
+}
+
+# Decision lines (emoji + text)
+/^🔀|^🚫|^✅|^✏️|^📐|^👍/ {
+  gsub(/\*\*/, "\033[1m")
+  printf " %s\n", $0 > "/dev/stderr"
+  next
+}
+
+# Routine decisions note
+/^\*\+/ {
+  gsub(/\*/, "")
+  printf " %s%s%s\n", DIM, $0, RST > "/dev/stderr"
+  next
+}
+
+# Recommendations header
+/^### Recommendations/ {
+  printf "\n %s%sRecommendations%s\n", BLD, "", RST > "/dev/stderr"
+  next
+}
+
+# Recommendation lines
+/^🔴|^🟡|^🟢/ {
+  printf " %s\n", $0 > "/dev/stderr"
+  next
+}
+' 2>&1
+
+exit 0

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "promptup-plugin",
+  "version": "0.1.1",
+  "description": "AI coding skill evaluator for Claude Code — 11-dimension scoring, decision intelligence, PR reports",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "promptup-plugin": "bin/promptup-plugin"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "hooks",
+    "skills",
+    "statusline.sh"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "evaluation",
+    "developer-tools",
+    "coding-skill",
+    "mcp",
+    "mcp-server",
+    "model-context-protocol",
+    "promptup",
+    "session-analysis",
+    "decision-quality",
+    "pr-report"
+  ],
+  "author": "gabikreal1",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gabikreal1/promptup-plugin.git"
+  },
+  "homepage": "https://github.com/gabikreal1/promptup-plugin",
+  "bugs": {
+    "url": "https://github.com/gabikreal1/promptup-plugin/issues"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "echo 'Ensure dist/ is built before publishing'"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "better-sqlite3": "^11.0.0",
+    "ulid": "^2.3.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.0",
+    "typescript": "^5.9.0"
+  }
+}

package/skills/eval/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: eval
+description: Evaluate the current coding session across 11 dimensions. Spawns an independent Claude analysis of your session transcript for unbiased scoring.
+user-invocable: true
+argument-hint: [session-id]
+---
+
+Call `mcp__promptup__evaluate_session` with the session ID from `$ARGUMENTS` if provided, otherwise no arguments.
+
+**CRITICAL: The tool returns a fully formatted markdown report. Output the ENTIRE tool response text verbatim in your reply — do NOT summarize, rephrase, or truncate any part of it. Include the full table, all progress bars, all decisions, and all recommendations exactly as returned. The user needs to see every line.**
+
+If the evaluation fails, explain what happened and suggest running `/status`.

package/skills/pr-report/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: pr-report
+description: Generate a Decision Quality Score (DQS) report for the current branch. Shows developer decisions made during AI-assisted coding, optionally posts to GitHub PR.
+user-invocable: true
+argument-hint: [--post] [--branch name]
+---
+
+# /pr-report — PR Decision Report
+
+Generate a decision quality report for the current git branch using PromptUp MCP tools.
+
+## Instructions
+
+1. Parse the user's arguments (`$ARGUMENTS`):
+   - If `--post` is present, set `post: true`
+   - If `--branch <name>` is present, set `branch` to that value
+   - Otherwise use defaults (current branch, no posting)
+
+2. Call the `mcp__promptup__generate_pr_report` tool with the parsed options.
+
+3. Display the returned **markdown report** directly — it contains:
+   - DQS score (Decision Quality Score, 0-100)
+   - Key decisions grouped by category (Architecture & Direction, Quality Gates, Scope Adjustments, Overrides)
+   - Summary table of decisions by type and signal level
+   - Commits list
+
+4. If `--post` was used and the report was posted to GitHub:
+   - Confirm: "Posted to PR #N"
+   - Show the PR URL
+
+5. If `--post` was used but posting failed:
+   - Explain why (no PR found, gh CLI not available, etc.)
+   - Suggest: install `gh` CLI, push branch first, create PR first
+
+6. If no sessions or decisions were found for the branch:
+   - Explain that PromptUp needs active session data
+   - Suggest running `/status` to check what's been tracked

package/skills/status/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: status
+description: Show PromptUp tracking status — recent sessions, evaluations, and decision counts.
+user-invocable: true
+---
+
+# /status — PromptUp Status
+
+Show the current state of PromptUp tracking.
+
+## Instructions
+
+1. Call the `mcp__promptup__get_status` tool.
+
+2. Present the results as a clean summary:
+
+   **PromptUp Status**
+   - Sessions tracked: N
+   - Evaluations completed: N
+   - Decisions captured: N
+   - Latest session: [id] (started X ago)
+   - Latest eval score: X/100
+   - Tool events logged: N
+
+3. If no data exists yet, explain:
+   - PromptUp tracks sessions passively via hooks
+   - Run `/eval` after a coding session to generate scores
+   - Run `/pr-report` on a branch with commits to see decision analysis

package/statusline.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+DB="${CLAUDE_PLUGIN_DATA:-$HOME/.promptup}/promptup.db"
+DATA_DIR="${CLAUDE_PLUGIN_DATA:-$HOME/.promptup}"
+CONFIG_FILE="$DATA_DIR/config.json"
+UPDATE_FILE="$DATA_DIR/update-available"
+
+if [ ! -f "$DB" ]; then
+  echo "pupmeter: --"
+  exit 0
+fi
+
+SCORE=$(sqlite3 "$DB" "SELECT composite_score FROM evaluations ORDER BY created_at DESC LIMIT 1" 2>/dev/null)
+SCORE_INT=$(printf "%.0f" "${SCORE:-0}")
+
+FILLED=$((SCORE_INT / 10))
+EMPTY=$((10 - FILLED))
+BAR=""
+for i in $(seq 1 $FILLED 2>/dev/null); do BAR="${BAR}█"; done
+for i in $(seq 1 $EMPTY 2>/dev/null); do BAR="${BAR}░"; done
+
+# Check for update
+UPDATE=""
+if [ -f "$UPDATE_FILE" ]; then
+  NEW_VER=$(cat "$UPDATE_FILE")
+  UPDATE=" │ ⬆ ${NEW_VER}"
+fi
+
+echo "pupmeter ${BAR} ${SCORE_INT}%${UPDATE}"
+
+# Show recommendation if enabled
+SHOW_REC=$(python3 -c "import json; c=json.load(open('$CONFIG_FILE')); print(c.get('statusline',{}).get('show_recommendation',True))" 2>/dev/null || echo "True")
+if [ "$SHOW_REC" = "True" ]; then
+  REC=$(sqlite3 "$DB" "SELECT recommendations FROM evaluations WHERE recommendations IS NOT NULL ORDER BY created_at DESC LIMIT 1" 2>/dev/null)
+  if [ -n "$REC" ]; then
+    TIP=$(echo "$REC" | python3 -c "
+import sys,json
+try:
+  r=json.load(sys.stdin)
+  if r: print(r[0].get('recommendation','')[:60])
+except: pass
+" 2>/dev/null)
+    if [ -n "$TIP" ]; then
+      echo "💡 ${TIP}"
+    fi
+  fi
+fi