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

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/prompt.js

@@ -335,6 +335,12 @@ function buildPrompt(template, ctx, rules, options, env = 'claude') {
         lines.push('');
     }
 
+    // ── Telemetry instructions ─────────────────────────────────
+    const ticketArg = ctx?.taskId ? ` --ticket ${ctx.taskId}` : '';
+    const akCmd = isWSL() ? 'ak.cmd' : 'ak';
+    lines.push(`> **Telemetry (required):** When **starting** each gate run \`${akCmd} gate N start${ticketArg}\`. When **APPROVED** run \`${akCmd} gate N approved${ticketArg}\`. Replace N with the gate number (1–5).`);
+    lines.push('');
+
     // ── Context section ────────────────────────────────────────
     if (ctx) {
         lines.push('## Context');
@@ -409,6 +415,14 @@ function buildPrompt(template, ctx, rules, options, env = 'claude') {
     return lines.join('\n');
 }
 
+function isWSL() {
+    if (process.platform !== 'linux') return false;
+    try {
+        const version = require('fs').readFileSync('/proc/version', 'utf-8');
+        return /microsoft|wsl/i.test(version);
+    } catch (_) { return false; }
+}
+
 function copyToClipboard(text) {
     try {
         if (process.platform === 'win32') {
@@ -420,6 +434,13 @@ function copyToClipboard(text) {
             );
         } else if (process.platform === 'darwin') {
             spawnSync('pbcopy', [], { input: text, encoding: 'utf8', stdio: ['pipe', 'ignore', 'ignore'] });
+        } else if (isWSL()) {
+            spawnSync(
+                'powershell.exe',
+                ['-NoProfile', '-NonInteractive', '-Command',
+                 '[Console]::InputEncoding = [System.Text.Encoding]::UTF8; Set-Clipboard -Value ([Console]::In.ReadToEnd())'],
+                { input: text, encoding: 'utf8', stdio: ['pipe', 'ignore', 'ignore'] }
+            );
         } else {
             const r = spawnSync('xclip', ['-selection', 'clipboard'], { input: text, encoding: 'utf8', stdio: ['pipe', 'ignore', 'ignore'] });
             if (r.error) spawnSync('xsel', ['--clipboard', '--input'], { input: text, encoding: 'utf8', stdio: ['pipe', 'ignore', 'ignore'] });

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/cli.js

@@ -232,12 +232,23 @@ module.exports = function telemetryCommand(action, options) {
 };
 
 function logEvent(options) {
-  const { record } = require('./record');
-  const event = options.event || 'custom_event';
-  const detail = options.detail || '';
-  if (!detail) {
-    record(event);
-  } else {
-    record(event, { detail });
-  }
+  try {
+    const { record } = require('./record');
+    const event = (options && options.event) || 'custom_event';
+    const detail = (options && options.detail) || '';
+    const result = detail ? record(event, { detail }) : record(event);
+
+    if (!result) return;
+    if (result.ok) {
+      console.log(chalk.green(`  [tel] ✓ '${event}' logged`));
+    } else if (result.reason === 'disabled') {
+      console.log(chalk.yellow(`  [tel] ⚠ skipped — telemetry is disabled (run 'aiflow telemetry enable')`));
+    } else if (result.reason === 'opted-out') {
+      console.log(chalk.yellow(`  [tel] ⚠ skipped — repo has .aiflow/no-telemetry opt-out`));
+    } else if (result.reason === 'no-url') {
+      console.log(chalk.yellow(`  [tel] ⚠ skipped — no server URL configured (run 'aiflow telemetry enable')`));
+    } else if (result.error) {
+      console.log(chalk.yellow(`  [tel] ⚠ error logging '${event}': ${result.error}`));
+    }
+  } catch (e) { /* never block main flow */ }
 }

package/scripts/telemetry/record.js

@@ -61,8 +61,9 @@ function logInternalError(err) {
 function record(eventType, payload = {}) {
   try {
     const cfg = loadConfig();
-    if (!cfg.enabled) return;
-    if (isRepoOptedOut()) return;
+    if (!cfg.enabled) return { ok: false, reason: 'disabled' };
+    if (isRepoOptedOut()) return { ok: false, reason: 'opted-out' };
+    if (!cfg.apps_script_url) return { ok: false, reason: 'no-url' };
 
     ensureDirectories();
 
@@ -70,6 +71,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,13 +82,16 @@ 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;
 
     const lineStr = signEvent(event, cfg.team_secret);
     fs.appendFileSync(BUFFER_PATH, lineStr + '\n');
-    
+
     // Check if buffer is getting huge (> 10MB cap). Simple clear
     try {
       if (fs.statSync(BUFFER_PATH).size > 10 * 1024 * 1024) {
@@ -95,8 +100,10 @@ function record(eventType, payload = {}) {
     } catch (e) {}
 
     maybeSpawnFlusher(cfg);
+    return { ok: true };
   } catch (err) {
     logInternalError(err);
+    return { ok: false, error: err.message };
   }
 }