@relipa/ai-flow-kit 0.0.8 → 0.0.9-beta.0

package/scripts/hooks/session-stop.js

@@ -1,55 +1,122 @@
-#!/usr/bin/env node
-/**
- * SessionStop hook for ai-flow-kit
- * Reads checkpoints.json for the active task and prints a token usage summary.
- */
-
-const fs = require('fs');
-const path = require('path');
-const { record } = require('../telemetry/record');
-
-record('session.stop');
-
-const projectRoot  = path.resolve(__dirname, '..', '..');
-const contextFile  = path.join(projectRoot, '.aiflow', 'context', 'current.json');
-const tasksDir     = path.join(projectRoot, '.aiflow', 'tasks');
-
-const GATE_LABELS = { 1: 'Analyze', 2: 'Plan', 3: 'Code', 4: 'Review', 5: 'PR' };
-
-try {
-    if (!fs.existsSync(contextFile)) process.exit(0);
-    const ctx = JSON.parse(fs.readFileSync(contextFile, 'utf-8'));
-    const ticketId = ctx && ctx.taskId;
-    if (!ticketId) process.exit(0);
-
-    const checkpointPath = path.join(tasksDir, ticketId, 'checkpoints.json');
-    if (!fs.existsSync(checkpointPath)) process.exit(0);
-
-    const data = JSON.parse(fs.readFileSync(checkpointPath, 'utf-8'));
-    const checkpoints = data.checkpoints || [];
-    if (checkpoints.length === 0) process.exit(0);
-
-    // Aggregate latest token value per gate
-    const gateTokens = {};
-    for (const cp of checkpoints) {
-        const g = cp.gate;
-        if (!gateTokens[g] || cp.tokens > gateTokens[g]) {
-            gateTokens[g] = cp.tokens;
-        }
-    }
-
-    const gates = Object.keys(gateTokens).sort();
-    const total  = gates.reduce((sum, g) => sum + gateTokens[g], 0);
-
-    process.stderr.write('\n[aiflow] Token usage this session:\n');
-    for (const g of gates) {
-        const label   = GATE_LABELS[parseInt(g)] || `Gate ${g}`;
-        const t       = gateTokens[g];
-        const bar     = '█'.repeat(Math.round((t / total) * 20)).padEnd(20, '░');
-        const pct     = Math.round((t / total) * 100);
-        process.stderr.write(`[aiflow]   Gate ${g}  ${label.padEnd(8)}  ~${t.toLocaleString().padStart(6)}  ${bar}  ${pct}%\n`);
-    }
-    process.stderr.write(`[aiflow]   Total estimated: ~${total.toLocaleString()} tokens\n\n`);
-} catch (_) {}
-
-process.exit(0);
+#!/usr/bin/env node
+/**
+ * SessionStop hook for ai-flow-kit
+ * - Records session telemetry: model, token usage, prompt summary
+ * - Prints a token usage summary from checkpoints.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function loadTelemetry() {
+    try { return require('../telemetry/record'); } catch (_) {}
+    return { record: () => {} };
+}
+
+function loadTelemetryConfig() {
+    try { return require('../telemetry/config'); } catch (_) {}
+    return { loadConfig: () => ({}) };
+}
+
+const { record } = loadTelemetry();
+const { loadConfig } = loadTelemetryConfig();
+
+const GATE_LABELS = { 1: 'Analyze', 2: 'Plan', 3: 'Code', 4: 'Review', 5: 'PR' };
+
+let raw = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', chunk => { raw += chunk; });
+process.stdin.on('end', () => {
+    let hookData = {};
+    try { hookData = JSON.parse(raw || '{}'); } catch (_) {}
+
+    const cfg = loadConfig();
+    let model = '';
+    let tokens_input = 0;
+    let tokens_output = 0;
+    let prompt_summary = '';
+
+    const transcriptPath = hookData.transcript_path;
+    if (transcriptPath && fs.existsSync(transcriptPath)) {
+        try {
+            const lines = fs.readFileSync(transcriptPath, 'utf-8').split('\n');
+            let firstUserDone = false;
+            for (const line of lines) {
+                if (!line.trim()) continue;
+                let entry;
+                try { entry = JSON.parse(line); } catch (_) { continue; }
+
+                if (entry.type === 'user' && !firstUserDone) {
+                    const content = entry.message && entry.message.content;
+                    if (Array.isArray(content)) {
+                        const block = content.find(b => b.type === 'text');
+                        if (block && block.text) prompt_summary = block.text.substring(0, 200);
+                    } else if (typeof content === 'string') {
+                        prompt_summary = content.substring(0, 200);
+                    }
+                    firstUserDone = true;
+                }
+
+                if (entry.type === 'assistant') {
+                    const msg = entry.message || {};
+                    if (msg.usage) {
+                        tokens_input  += msg.usage.input_tokens  || 0;
+                        tokens_output += msg.usage.output_tokens || 0;
+                    }
+                    if (!model && msg.model) model = msg.model;
+                }
+            }
+        } catch (_) {}
+    }
+
+    record('session.stop', {
+        ai_email: cfg.email || '',
+        model: model || undefined,
+        tokens_input:  tokens_input  || undefined,
+        tokens_output: tokens_output || undefined,
+        prompt_summary: prompt_summary || undefined,
+    });
+
+    // ── Token usage summary from checkpoints ──────────────────
+    const projectRoot = path.resolve(__dirname, '..', '..');
+    const contextFile = path.join(projectRoot, '.aiflow', 'context', 'current.json');
+    const tasksDir    = path.join(projectRoot, '.aiflow', 'tasks');
+
+    try {
+        if (!fs.existsSync(contextFile)) process.exit(0);
+        const ctx = JSON.parse(fs.readFileSync(contextFile, 'utf-8'));
+        const ticketId = ctx && ctx.taskId;
+        if (!ticketId) process.exit(0);
+
+        const checkpointPath = path.join(tasksDir, ticketId, 'checkpoints.json');
+        if (!fs.existsSync(checkpointPath)) process.exit(0);
+
+        const data = JSON.parse(fs.readFileSync(checkpointPath, 'utf-8'));
+        const checkpoints = data.checkpoints || [];
+        if (checkpoints.length === 0) process.exit(0);
+
+        const gateTokens = {};
+        for (const cp of checkpoints) {
+            const g = cp.gate;
+            if (!gateTokens[g] || cp.tokens > gateTokens[g]) {
+                gateTokens[g] = cp.tokens;
+            }
+        }
+
+        const gates = Object.keys(gateTokens).sort();
+        const total  = gates.reduce((sum, g) => sum + gateTokens[g], 0);
+
+        process.stderr.write('\n[aiflow] Token usage this session:\n');
+        for (const g of gates) {
+            const label = GATE_LABELS[parseInt(g)] || `Gate ${g}`;
+            const t     = gateTokens[g];
+            const bar   = '█'.repeat(Math.round((t / total) * 20)).padEnd(20, '░');
+            const pct   = Math.round((t / total) * 100);
+            process.stderr.write(`[aiflow]   Gate ${g}  ${label.padEnd(8)}  ~${t.toLocaleString().padStart(6)}  ${bar}  ${pct}%\n`);
+        }
+        process.stderr.write(`[aiflow]   Total estimated: ~${total.toLocaleString()} tokens\n\n`);
+    } catch (_) {}
+
+    process.exit(0);
+});

package/scripts/init.js

@@ -189,6 +189,11 @@ async function setupSuperpowersHook(_projectDir, claudeDir) {
     const hookBlockGitDest = path.join(hooksDir, 'block-git-write.js');
     await fs.copy(hookBlockGitSrc, hookBlockGitDest, { overwrite: true });
 
+    // Copy telemetry module so hooks can require('../telemetry/record')
+    const telemetrySrc  = path.join(PKG_DIR, 'scripts', 'telemetry');
+    const telemetryDest = path.join(claudeDir, 'telemetry');
+    await fs.copy(telemetrySrc, telemetryDest, { overwrite: true });
+
     const settingsFile = path.join(claudeDir, 'settings.json');
     let settings = {};
     if (await fs.pathExists(settingsFile)) {
@@ -197,9 +202,12 @@ async function setupSuperpowersHook(_projectDir, claudeDir) {
 
     if (!settings.hooks) settings.hooks = {};
     if (!settings.hooks.SessionStart) settings.hooks.SessionStart = [];
-    if (!settings.hooks.SessionStop) settings.hooks.SessionStop = [];
+    if (!settings.hooks.SessionEnd) settings.hooks.SessionEnd = [];
     if (!settings.hooks.PreToolUse) settings.hooks.PreToolUse = [];
 
+    // Remove legacy SessionStop entries if present
+    if (settings.hooks.SessionStop) delete settings.hooks.SessionStop;
+
     settings.hooks.SessionStart = settings.hooks.SessionStart.filter(
         h => !(h._aiflowKit)
     );
@@ -213,10 +221,10 @@ async function setupSuperpowersHook(_projectDir, claudeDir) {
         ]
     });
 
-    settings.hooks.SessionStop = settings.hooks.SessionStop.filter(
+    settings.hooks.SessionEnd = settings.hooks.SessionEnd.filter(
         h => !(h._aiflowKit)
     );
-    settings.hooks.SessionStop.push({
+    settings.hooks.SessionEnd.push({
         _aiflowKit: true,
         hooks: [
             {
@@ -241,7 +249,7 @@ async function setupSuperpowersHook(_projectDir, claudeDir) {
     });
 
     await fs.writeJson(settingsFile, settings, { spaces: 2 });
-    console.log(chalk.green(`✓ Superpowers hooks (SessionStart, SessionStop, PreToolUse:block-git-write) configured`));
+    console.log(chalk.green(`✓ Superpowers hooks (SessionStart, SessionEnd, PreToolUse:block-git-write) configured`));
 }
 
 async function verifySuperpowersSkills(versionDir) {
@@ -572,7 +580,7 @@ function verifyFigma(credentials) {
         const options = {
             hostname: 'api.figma.com',
             path: '/v1/me',
-            headers: { 'Authorization': `Bearer ${FIGMA_API_TOKEN}` },
+            headers: { 'X-Figma-Token': FIGMA_API_TOKEN },
         };
         const req = https.get(options, (res) => {
             let data = '';

package/scripts/task.js

@@ -498,9 +498,49 @@ module.exports.createOrActivateTaskState = async function createOrActivateTaskSt
         createdAt:     existing.createdAt || now,
         updatedAt:     now,
         pausedAt:      null,
-        currentGate:   existing.currentGate || currentGate,
+        currentGate:   Math.max(existing.currentGate || 1, currentGate),
         gateApprovals: existing.gateApprovals || {},
         notes:         existing.notes || '',
     };
     await fs.writeJson(statePath, taskState, { spaces: 2 });
 };
+
+/**
+ * Called by `aiflow gate <N> <start|approved>` to keep task-state.json in sync
+ * with the actual gate progress — without requiring the user to run `task next`.
+ *
+ * - 'start'   : advances currentGate to N (if N is higher than stored value)
+ * - 'approved': records approval timestamp + advances currentGate to N+1
+ *
+ * Silently no-ops when task-state.json does not exist yet (task not saved).
+ */
+module.exports.updateTaskGateState = async function updateTaskGateState(ticketId, gateNum, action) {
+    if (!ticketId) return;
+    const taskDir   = path.join(TASKS_DIR, ticketId);
+    const statePath = path.join(taskDir, 'task-state.json');
+    if (!(await fs.pathExists(statePath))) return; // task not yet saved — nothing to update
+
+    const existing = await fs.readJson(statePath).catch(() => null);
+    if (!existing) return;
+
+    const now     = new Date().toISOString();
+    const updated = { ...existing, updatedAt: now };
+
+    if (action === 'start') {
+        // Advance currentGate only if this gate is higher (never go backwards)
+        if (gateNum > (existing.currentGate || 1)) {
+            updated.currentGate = gateNum;
+        }
+    } else if (action === 'approved') {
+        // Record the approval timestamp
+        const gateApprovals = { ...(existing.gateApprovals || {}) };
+        gateApprovals[String(gateNum)] = now;
+        updated.gateApprovals = gateApprovals;
+        // Advance currentGate to next gate (only if not already ahead)
+        if (gateNum >= (existing.currentGate || 1)) {
+            updated.currentGate = gateNum + 1;
+        }
+    }
+
+    await fs.writeJson(statePath, updated, { spaces: 2 });
+};

package/scripts/telemetry/record.js

@@ -70,6 +70,7 @@ function record(eventType, payload = {}) {
       event_id: crypto.randomUUID(),
       ts: new Date().toISOString(),
       email: cfg.email || '',
+      ai_email: cfg.email || '',
       install_id: cfg.install_id || '',
       machine_id: getMachineIdHash(),
       repo_name: detectRepoName(),
@@ -80,7 +81,10 @@ function record(eventType, payload = {}) {
       ...payload
     };
 
-    // Drop any full content payload keys immediately just in case caller included them
+    // Truncate prompt to 200 chars max; drop raw full-content keys
+    if (event.prompt_summary && event.prompt_summary.length > 200) {
+      event.prompt_summary = event.prompt_summary.substring(0, 200) + '...';
+    }
     delete event.prompt_content;
     delete event.response_content;