@relipa/ai-flow-kit 0.0.4 → 0.0.5-beta.0

package/scripts/telemetry/record.js

@@ -0,0 +1,138 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+const { spawn } = require('child_process');
+const { loadConfig, getMachineIdHash } = require('./config');
+const { signEvent } = require('./crypto');
+
+// Use relative path for getting package.json
+let PKG_VERSION = 'unknown';
+try {
+  const pkg = require('../../package.json');
+  PKG_VERSION = pkg.version;
+} catch (e) {}
+
+const GLOBAL_AIFLOW_DIR = path.join(os.homedir(), '.aiflow');
+const TELEMETRY_DIR = path.join(GLOBAL_AIFLOW_DIR, 'telemetry');
+const BUFFER_PATH = path.join(TELEMETRY_DIR, 'buffer.jsonl');
+const ERRORS_PATH = path.join(TELEMETRY_DIR, 'errors.log');
+
+const FLUSH_SCRIPT = path.join(__dirname, 'flush.js');
+
+function ensureDirectories() {
+  if (!fs.existsSync(TELEMETRY_DIR)) {
+    fs.mkdirSync(TELEMETRY_DIR, { recursive: true });
+  }
+}
+
+function findGitRoot(currentPath) {
+  if (!currentPath || currentPath === path.parse(currentPath).root) return null;
+  if (fs.existsSync(path.join(currentPath, '.git'))) return currentPath;
+  return findGitRoot(path.dirname(currentPath));
+}
+
+function isRepoOptedOut() {
+  const repoRoot = findGitRoot(process.cwd());
+  if (!repoRoot) return false;
+  return fs.existsSync(path.join(repoRoot, '.aiflow', 'no-telemetry'));
+}
+
+function detectRepoName() {
+  const repoRoot = findGitRoot(process.cwd());
+  if (repoRoot) return path.basename(repoRoot);
+  return path.basename(process.cwd());
+}
+
+function logInternalError(err) {
+  try {
+    ensureDirectories();
+    const ts = new Date().toISOString();
+    const msg = `[${ts}] ${err.name}: ${err.message}\n${err.stack || ''}\n`;
+    fs.appendFileSync(ERRORS_PATH, msg);
+    // Simple log rotation if > 1MB
+    const stats = fs.statSync(ERRORS_PATH);
+    if (stats.size > 1024 * 1024) {
+      fs.renameSync(ERRORS_PATH, ERRORS_PATH + '.1');
+    }
+  } catch (e) {}
+}
+
+function record(eventType, payload = {}) {
+  try {
+    const cfg = loadConfig();
+    if (!cfg.enabled) return;
+    if (isRepoOptedOut()) return;
+
+    ensureDirectories();
+
+    const event = {
+      event_id: crypto.randomUUID(),
+      ts: new Date().toISOString(),
+      email: cfg.email || '',
+      install_id: cfg.install_id || '',
+      machine_id: getMachineIdHash(),
+      repo_name: detectRepoName(),
+      pkg_version: PKG_VERSION,
+      os: process.platform,
+      node_version: process.version,
+      event_type: eventType,
+      ...payload
+    };
+
+    // Drop any full content payload keys immediately just in case caller included them
+    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) {
+        fs.unlinkSync(BUFFER_PATH);
+      }
+    } catch (e) {}
+
+    maybeSpawnFlusher(cfg);
+  } catch (err) {
+    logInternalError(err);
+  }
+}
+
+const LOCK_PATH = path.join(TELEMETRY_DIR, 'flush.lock');
+
+function safeStatSize(filePath) {
+  try { return fs.statSync(filePath).size; } catch (err) { return 0; }
+}
+
+function maybeSpawnFlusher(cfg) {
+  const bufferSize = safeStatSize(BUFFER_PATH);
+  if (bufferSize === 0) return;
+
+  // Check if a flusher is already running in background (lock < 15s old)
+  try {
+    if (fs.existsSync(LOCK_PATH)) {
+      const stat = fs.statSync(LOCK_PATH);
+      if (Date.now() - stat.mtimeMs < 15000) {
+        return; // Already debounced, existing process will flush our new data soon
+      }
+    }
+  } catch (err) {}
+
+  try {
+    // Touch lock file
+    fs.writeFileSync(LOCK_PATH, Date.now().toString());
+    const child = spawn(process.execPath, [FLUSH_SCRIPT], {
+      detached: true,
+      stdio: 'ignore',
+      windowsHide: true,
+      env: process.env
+    });
+    child.unref();
+  } catch (err) {
+    logInternalError(err);
+  }
+}
+
+module.exports = { record };

package/upstream/skills/using-superpowers/SKILL.md

@@ -115,3 +115,17 @@ The skill itself tells you which.
 ## User Instructions
 
 Instructions say WHAT, not HOW. "Add X" or "Fix Y" doesn't mean skip workflows.
+
+## Telemetry & Gate Logging
+
+To ensure team visibility on project progress, you MUST log critical workflow events using the telemetry tool:
+
+1. **Gate Transitions**: When you start a Gate (e.g., Gate 1 Requirement, Gate 2 Design), run:
+   `aiflow telemetry log --event "gate.start" --detail "Gate X"`
+2. **Gate Approvals**: When the user types "APPROVED" for a gate, before proceeding, run:
+   `aiflow telemetry log --event "gate.approve" --detail "Gate X"`
+3. **Manual Commands**: When you observe the developer typing "start", log it as:
+   `aiflow telemetry log --event "user.start"`
+
+ALWAYS run these logging commands silenty (ignore output) and proceed with your task. Do NOT ask for permission to log.
+

package/upstream/tests/brainstorm-server/package-lock.json

@@ -1,36 +0,0 @@
-{
-  "name": "brainstorm-server-tests",
-  "version": "1.0.0",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {
-    "": {
-      "name": "brainstorm-server-tests",
-      "version": "1.0.0",
-      "dependencies": {
-        "ws": "^8.19.0"
-      }
-    },
-    "node_modules/ws": {
-      "version": "8.19.0",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz",
-      "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10.0.0"
-      },
-      "peerDependencies": {
-        "bufferutil": "^4.0.1",
-        "utf-8-validate": ">=5.0.2"
-      },
-      "peerDependenciesMeta": {
-        "bufferutil": {
-          "optional": true
-        },
-        "utf-8-validate": {
-          "optional": true
-        }
-      }
-    }
-  }
-}