thumbgate 1.4.3 → 1.4.4

package/scripts/skill-quality-tracker.js

@@ -1,282 +0,0 @@
-#!/usr/bin/env node
-/**
- * Skill Quality Tracker
- *
- * Correlates tool call metrics to feedback signals by timestamp proximity.
- * After a sequence of tool calls and feedback captures, produces a per-skill
- * quality score derived from timestamp-proximity correlation.
- *
- * Ported from Subway_RN_Demo/.claude/scripts/feedback/skill-quality-tracker.js
- * PATH: PROJECT_ROOT = path.join(__dirname, '..') — 1 level up from scripts/
- */
-
-'use strict';
-
-const fs = require('fs');
-const readline = require('readline');
-const path = require('path');
-const { resolveFeedbackDir } = require('./feedback-paths');
-
-const METRICS_PATH = process.env.METRICS_PATH
-  || path.join(resolveFeedbackDir(), 'tool-metrics.jsonl');
-
-const FEEDBACK_PATH = process.env.FEEDBACK_PATH
-  || path.join(resolveFeedbackDir(), 'feedback-log.jsonl');
-
-// Correlation window: feedback within 60 seconds of a tool call is considered correlated
-const CORRELATION_WINDOW_MS = 60_000;
-
-/**
- * Safely parse a single JSON line.
- *
- * @param {string} line
- * @returns {object|null}
- */
-function parseLine(line) {
-  try {
-    return JSON.parse(line);
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Load feedback entries from JSONL file.
- * Each entry needs: timestamp, feedback (signal).
- *
- * @param {string} filePath
- * @returns {Promise<Array<{ ts: number, feedback: string, tool: string|null }>>}
- */
-async function loadFeedback(filePath) {
-  const entries = [];
-  if (!fs.existsSync(filePath)) return entries;
-
-  const rl = readline.createInterface({
-    input: fs.createReadStream(filePath),
-    crlfDelay: Infinity,
-  });
-
-  for await (const line of rl) {
-    const obj = parseLine(line);
-    if (obj && obj.timestamp) {
-      // Support both 'feedback' (Subway) and 'signal' (ThumbGate) field names
-      const feedbackVal = obj.feedback || obj.signal;
-      if (feedbackVal) {
-        // Normalize to 'positive'/'negative' regardless of source schema
-        let normalized = feedbackVal;
-        if (feedbackVal === 'up') normalized = 'positive';
-        else if (feedbackVal === 'down') normalized = 'negative';
-
-        entries.push({
-          ts: new Date(obj.timestamp).getTime(),
-          feedback: normalized,
-          tool: obj.tool_name || null,
-        });
-      }
-    }
-  }
-
-  entries.sort((a, b) => a.ts - b.ts);
-  return entries;
-}
-
-/**
- * Find correlated feedback for a tool call by timestamp proximity.
- *
- * Searches feedback entries within CORRELATION_WINDOW_MS of the metric timestamp.
- * If the feedback entry has a tool_name, it must match the metric's tool name.
- *
- * @param {number} metricTs - Timestamp of the tool call (ms)
- * @param {string} metricTool - Tool name
- * @param {Array<{ ts: number, feedback: string, tool: string|null }>} feedbackEntries
- * @returns {string|null} 'positive', 'negative', or null if no correlation found
- */
-function correlateFeedback(metricTs, metricTool, feedbackEntries) {
-  for (const fb of feedbackEntries) {
-    if (Math.abs(fb.ts - metricTs) <= CORRELATION_WINDOW_MS) {
-      // If feedback has a tool name, it must match; otherwise correlate by time alone
-      if (!fb.tool || fb.tool === metricTool) {
-        return fb.feedback;
-      }
-    }
-  }
-  return null;
-}
-
-/**
- * Process tool metrics JSONL and correlate with feedback.
- *
- * @param {string} metricsPath
- * @param {Array<{ ts: number, feedback: string, tool: string|null }>} feedbackEntries
- * @returns {Promise<{ totalToolUses: number, breakdown: object }>}
- */
-async function processMetrics(metricsPath, feedbackEntries) {
-  const breakdown = {};
-  let totalToolUses = 0;
-
-  if (!fs.existsSync(metricsPath)) return { totalToolUses, breakdown };
-
-  const rl = readline.createInterface({
-    input: fs.createReadStream(metricsPath),
-    crlfDelay: Infinity,
-  });
-
-  for await (const line of rl) {
-    const obj = parseLine(line);
-    if (!obj || !obj.tool_name) continue;
-
-    totalToolUses++;
-    const name = obj.tool_name;
-
-    if (!breakdown[name]) {
-      breakdown[name] = { uses: 0, correlatedPositive: 0, correlatedNegative: 0 };
-    }
-
-    breakdown[name].uses++;
-
-    const ts = new Date(obj.timestamp).getTime();
-    if (!isNaN(ts)) {
-      const signal = correlateFeedback(ts, name, feedbackEntries);
-      if (signal === 'positive') breakdown[name].correlatedPositive++;
-      else if (signal === 'negative') breakdown[name].correlatedNegative++;
-    }
-  }
-
-  return { totalToolUses, breakdown };
-}
-
-/**
- * Compute per-tool success rates from correlation counts.
- * Mutates the breakdown object in place.
- *
- * @param {object} breakdown - { toolName: { uses, correlatedPositive, correlatedNegative } }
- */
-function computeSuccessRates(breakdown) {
-  for (const tool of Object.values(breakdown)) {
-    const correlated = tool.correlatedPositive + tool.correlatedNegative;
-    tool.successRate = correlated > 0
-      ? +(tool.correlatedPositive / correlated).toFixed(4)
-      : null;
-  }
-}
-
-/**
- * Return top-performing tools sorted by success rate.
- *
- * @param {object} breakdown
- * @param {number} [min=10] - Minimum uses threshold
- * @param {number} [limit=5] - Maximum entries to return
- * @returns {Array<{ tool: string, successRate: number, uses: number }>}
- */
-function topPerformers(breakdown, min = 10, limit = 5) {
-  return Object.entries(breakdown)
-    .filter(([, v]) => v.uses >= min && v.successRate !== null)
-    .sort((a, b) => b[1].successRate - a[1].successRate || b[1].uses - a[1].uses)
-    .slice(0, limit)
-    .map(([name, v]) => ({ tool: name, successRate: v.successRate, uses: v.uses }));
-}
-
-/**
- * Return tools with high negative correlation (potential trouble spots).
- * Threshold: >30% negative rate among correlated feedback.
- *
- * @param {object} breakdown
- * @returns {Array<{ tool: string, negativeRate: number, uses: number }>}
- */
-function troubleSpots(breakdown) {
-  return Object.entries(breakdown)
-    .filter(([, v]) => {
-      const total = v.correlatedPositive + v.correlatedNegative;
-      return total > 0 && v.correlatedNegative / total > 0.3;
-    })
-    .map(([name, v]) => {
-      const total = v.correlatedPositive + v.correlatedNegative;
-      return {
-        tool: name,
-        negativeRate: +(v.correlatedNegative / total).toFixed(4),
-        uses: v.uses,
-      };
-    })
-    .sort((a, b) => b.negativeRate - a.negativeRate);
-}
-
-/**
- * Generate actionable recommendations from top performers and trouble spots.
- *
- * @param {Array} top - topPerformers result
- * @param {Array} trouble - troubleSpots result
- * @param {object} breakdown - full breakdown
- * @returns {string[]}
- */
-function generateRecommendations(top, trouble, breakdown) {
-  const recs = [];
-
-  for (const t of trouble) {
-    recs.push(
-      `Investigate "${t.tool}" — ${(t.negativeRate * 100).toFixed(1)}% negative correlation across ${t.uses} uses.`
-    );
-  }
-
-  if (top.length > 0) {
-    recs.push(
-      `"${top[0].tool}" is the top performer (${(top[0].successRate * 100).toFixed(1)}% success). Consider expanding its usage patterns.`
-    );
-  }
-
-  const uncorrelated = Object.entries(breakdown).filter(
-    ([, v]) => v.uses >= 10 && v.successRate === null
-  );
-  if (uncorrelated.length > 0) {
-    recs.push(
-      `${uncorrelated.length} tool(s) with 10+ uses have no correlated feedback — consider adding coverage.`
-    );
-  }
-
-  if (recs.length === 0) recs.push('No actionable recommendations at this time.');
-  return recs;
-}
-
-/**
- * Main entry point: load data, correlate, produce report.
- *
- * @returns {Promise<object>} Full skill quality report
- */
-async function run() {
-  const feedbackEntries = await loadFeedback(FEEDBACK_PATH);
-  const { totalToolUses, breakdown } = await processMetrics(METRICS_PATH, feedbackEntries);
-
-  computeSuccessRates(breakdown);
-
-  const top = topPerformers(breakdown);
-  const trouble = troubleSpots(breakdown);
-  const recommendations = generateRecommendations(top, trouble, breakdown);
-
-  const report = {
-    generatedAt: new Date().toISOString(),
-    totalToolUses,
-    toolBreakdown: breakdown,
-    topPerformers: top,
-    troubleSpots: trouble,
-    recommendations,
-  };
-
-  console.log(JSON.stringify(report, null, 2));
-  return report;
-}
-
-if (require.main === module) {
-  run().catch(() => {}).finally(() => process.exit(0));
-}
-
-module.exports = {
-  parseLine,
-  correlateFeedback,
-  computeSuccessRates,
-  topPerformers,
-  troubleSpots,
-  generateRecommendations,
-  loadFeedback,
-  processMetrics,
-  run,
-  CORRELATION_WINDOW_MS,
-};

package/scripts/slow-loop.js

@@ -1,72 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const { createSchedule } = require('./schedule-manager');
-const { resolveFeedbackDir } = require('./feedback-paths');
-
-const IDLE_THRESHOLD_MINUTES = 30;
-const SLOW_LOOP_STATE_FILE = 'slow-loop-state.json';
-
-function getStatePath() {
-  return path.join(resolveFeedbackDir(), SLOW_LOOP_STATE_FILE);
-}
-
-function loadState() {
-  const p = getStatePath();
-  if (!fs.existsSync(p)) return { lastExportAt: null, exportCount: 0, lastIdleCheckAt: null, totalPairsExported: 0 };
-  try { return JSON.parse(fs.readFileSync(p, 'utf-8')); } catch { return { lastExportAt: null, exportCount: 0, lastIdleCheckAt: null, totalPairsExported: 0 }; }
-}
-
-function saveState(state) {
-  const p = getStatePath();
-  const dir = path.dirname(p);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(p, JSON.stringify(state, null, 2) + '\n');
-}
-
-function isIdle({ thresholdMinutes = IDLE_THRESHOLD_MINUTES } = {}) {
-  const feedbackDir = resolveFeedbackDir();
-  const logPath = path.join(feedbackDir, 'feedback-log.jsonl');
-  if (!fs.existsSync(logPath)) return true;
-  try {
-    const stats = fs.statSync(logPath);
-    const minutesSinceModified = (Date.now() - stats.mtimeMs) / (1000 * 60);
-    return minutesSinceModified >= thresholdMinutes;
-  } catch { return true; }
-}
-
-function runSlowLoop({ thresholdMinutes = IDLE_THRESHOLD_MINUTES, force = false } = {}) {
-  const state = loadState();
-  const idle = force || isIdle({ thresholdMinutes });
-  if (!idle) { state.lastIdleCheckAt = new Date().toISOString(); saveState(state); return { action: 'skipped', reason: 'system not idle', idle: false, state }; }
-
-  const feedbackDir = resolveFeedbackDir();
-  const logPath = path.join(feedbackDir, 'feedback-log.jsonl');
-  let newEntries = 0;
-  if (fs.existsSync(logPath)) {
-    const totalEntries = fs.readFileSync(logPath, 'utf-8').trim().split('\n').filter(Boolean).length;
-    newEntries = totalEntries - (state.lastFeedbackCount || 0);
-    state.lastFeedbackCount = totalEntries;
-  }
-  if (newEntries <= 0 && !force) { state.lastIdleCheckAt = new Date().toISOString(); saveState(state); return { action: 'skipped', reason: 'no new feedback since last export', idle: true, newEntries: 0, state }; }
-
-  let dpoResult = null;
-  try { const { exportDpoPairs } = require('./feedback-loop'); dpoResult = exportDpoPairs(); } catch (err) { dpoResult = { error: err.message, pairsExported: 0 }; }
-
-  const pairsExported = dpoResult && dpoResult.pairs ? dpoResult.pairs.length : (dpoResult && dpoResult.pairsExported) || 0;
-  state.lastExportAt = new Date().toISOString();
-  state.exportCount = (state.exportCount || 0) + 1;
-  state.totalPairsExported = (state.totalPairsExported || 0) + pairsExported;
-  state.lastIdleCheckAt = new Date().toISOString();
-  saveState(state);
-  return { action: 'exported', idle: true, newEntries, pairsExported, totalExports: state.exportCount, totalPairsExported: state.totalPairsExported, exportedAt: state.lastExportAt, state };
-}
-
-function createSlowLoopSchedule({ schedule = 'hourly', thresholdMinutes = IDLE_THRESHOLD_MINUTES } = {}) {
-  const command = [`const sl = require(${JSON.stringify(__filename)});`, `const result = sl.runSlowLoop(${JSON.stringify({ thresholdMinutes })});`, 'process.stdout.write(JSON.stringify(result, null, 2) + "\\n");'].join(' ');
-  return createSchedule({ id: 'thumbgate-slow-loop', name: 'ThumbGate Slow Loop (DPO Export)', description: `Idle-time DPO export, runs ${schedule}`, schedule, command });
-}
-
-module.exports = { isIdle, runSlowLoop, createSlowLoopSchedule, loadState, getStatePath };

package/scripts/social-analytics/db/marketing-db.js

@@ -1,179 +0,0 @@
-'use strict';
-
-/**
- * marketing-db.js
- * Unified marketing activity database.
- *
- * Tracks every post, video, article, and reply published to any platform
- * so we never double-post and can measure marketing effort over time.
- *
- * DB file: .thumbgate/marketing-analytics.sqlite by default. The schema is
- * tracked in this directory, but runtime SQLite files stay local/ignored.
- *
- * Usage:
- *   const db = require('./marketing-db');
- *   if (db.isDuplicate('twitter', contentHash)) return;
- *   const result = await publish(...);
- *   db.record({ type: 'post', platform: 'twitter', postUrl: result.url, contentHash, campaign: 'v1.4.1' });
- */
-
-const path = require('node:path');
-const fs = require('node:fs');
-const crypto = require('node:crypto');
-
-const REPO_ROOT = path.resolve(__dirname, '..', '..', '..');
-
-const DB_PATH = process.env.THUMBGATE_ANALYTICS_DB
-  ? path.resolve(process.env.THUMBGATE_ANALYTICS_DB)
-  : path.join(REPO_ROOT, '.thumbgate', 'marketing-analytics.sqlite');
-
-const SCHEMA_PATH = path.join(__dirname, 'schema.sql');
-
-let _db = null;
-
-function getDb() {
-  if (_db) return _db;
-  const Database = require('better-sqlite3');
-  fs.mkdirSync(path.dirname(DB_PATH), { recursive: true });
-  const isNew = !fs.existsSync(DB_PATH);
-  _db = new Database(DB_PATH);
-  _db.pragma('journal_mode = WAL');
-  _db.pragma('foreign_keys = ON');
-  // Always apply schema (idempotent — CREATE IF NOT EXISTS)
-  const schema = fs.readFileSync(SCHEMA_PATH, 'utf8');
-  _db.exec(schema);
-  if (isNew) console.log('[marketing-db] Created new analytics DB at', DB_PATH);
-  return _db;
-}
-
-/**
- * Hash content deterministically for dedup.
- * Normalises whitespace so minor edits don't bypass dedup.
- */
-function hashContent(content) {
-  const normalised = String(content).trim().replaceAll(/\s+/g, ' ');
-  return crypto.createHash('sha256').update(normalised).digest('hex').slice(0, 32);
-}
-
-/**
- * Check whether this content was already published to this platform.
- *
- * @param {string} platform  e.g. 'twitter', 'linkedin', 'youtube'
- * @param {string} contentHash  from hashContent() or a stable identifier
- * @param {number} [windowDays=7]  look-back window in days (0 = all-time)
- * @returns {object|null}  existing row if duplicate, null otherwise
- */
-function isDuplicate(platform, contentHash, windowDays = 7) {
-  const db = getDb();
-  let row;
-  if (windowDays > 0) {
-    const cutoff = new Date(Date.now() - windowDays * 86_400_000).toISOString();
-    row = db.prepare(`
-      SELECT id, post_url, published_at, status FROM marketing_posts
-      WHERE platform = ? AND content_hash = ? AND published_at >= ? AND status = 'published'
-      LIMIT 1
-    `).get(platform, contentHash, cutoff);
-  } else {
-    row = db.prepare(`
-      SELECT id, post_url, published_at, status FROM marketing_posts
-      WHERE platform = ? AND content_hash = ? AND status = 'published'
-      LIMIT 1
-    `).get(platform, contentHash);
-  }
-  return row || null;
-}
-
-/**
- * Record a marketing activity.
- *
- * @param {object} opts
- * @param {'post'|'video'|'article'|'reply'|'thread'} opts.type
- * @param {string}  opts.platform      e.g. 'twitter', 'youtube'
- * @param {string}  opts.contentHash   from hashContent()
- * @param {string}  [opts.postUrl]
- * @param {string}  [opts.postId]
- * @param {string}  [opts.accountId]
- * @param {string}  [opts.title]
- * @param {'published'|'failed'|'skipped'|'draft'} [opts.status='published']
- * @param {string[]} [opts.tags]
- * @param {string}  [opts.campaign]
- * @param {object}  [opts.extra]
- * @returns {number} inserted row id
- */
-function record(opts) {
-  const db = getDb();
-  const {
-    type, platform, contentHash,
-    postUrl = null, postId = null, accountId = null, title = null,
-    status = 'published', tags = [], campaign = null, extra = null,
-  } = opts;
-
-  const stmt = db.prepare(`
-    INSERT INTO marketing_posts
-      (type, platform, account_id, post_id, post_url, title,
-       content_hash, published_at, status, tags, campaign, extra_json)
-    VALUES (?,?,?,?,?,?,?,?,?,?,?,?)
-    ON CONFLICT(platform, content_hash) DO UPDATE SET
-      post_url    = excluded.post_url,
-      post_id     = excluded.post_id,
-      status      = excluded.status,
-      published_at= excluded.published_at,
-      extra_json  = excluded.extra_json
-  `);
-
-  const result = stmt.run(
-    type, platform, accountId, postId, postUrl, title,
-    contentHash,
-    new Date().toISOString(),
-    status,
-    JSON.stringify(tags),
-    campaign,
-    extra ? JSON.stringify(extra) : null,
-  );
-  return result.lastInsertRowid;
-}
-
-/**
- * List recent marketing posts, optionally filtered.
- *
- * @param {{ platform?: string, type?: string, campaign?: string, limit?: number, days?: number }} opts
- * @returns {object[]}
- */
-function list({ platform, type, campaign, limit = 50, days = 30 } = {}) {
-  const db = getDb();
-  const conditions = [];
-  const params = [];
-
-  if (platform) { conditions.push('platform = ?'); params.push(platform); }
-  if (type) { conditions.push('type = ?'); params.push(type); }
-  if (campaign) { conditions.push('campaign = ?'); params.push(campaign); }
-  if (days > 0) {
-    conditions.push('published_at >= ?');
-    params.push(new Date(Date.now() - days * 86_400_000).toISOString());
-  }
-
-  const where = conditions.length ? `WHERE ${conditions.join(' AND ')}` : '';
-  params.push(limit);
-
-  return db.prepare(`
-    SELECT * FROM marketing_posts
-    ${where}
-    ORDER BY published_at DESC
-    LIMIT ?
-  `).all(...params);
-}
-
-/**
- * Return a summary count by platform and type.
- */
-function summary() {
-  const db = getDb();
-  return db.prepare(`
-    SELECT platform, type, status, COUNT(*) as count
-    FROM marketing_posts
-    GROUP BY platform, type, status
-    ORDER BY count DESC
-  `).all();
-}
-
-module.exports = { hashContent, isDuplicate, record, list, summary, getDb };

package/scripts/social-analytics/db/schema.sql

@@ -1,55 +0,0 @@
-CREATE TABLE IF NOT EXISTS engagement_metrics (
-  id            INTEGER PRIMARY KEY AUTOINCREMENT,
-  platform      TEXT NOT NULL,
-  content_type  TEXT NOT NULL,
-  post_id       TEXT NOT NULL,
-  post_url      TEXT,
-  published_at  TEXT,
-  metric_date   TEXT NOT NULL,
-  impressions   INTEGER DEFAULT 0,
-  reach         INTEGER DEFAULT 0,
-  likes         INTEGER DEFAULT 0,
-  comments      INTEGER DEFAULT 0,
-  shares        INTEGER DEFAULT 0,
-  saves         INTEGER DEFAULT 0,
-  clicks        INTEGER DEFAULT 0,
-  video_views   INTEGER DEFAULT 0,
-  followers_delta INTEGER DEFAULT 0,
-  extra_json    TEXT,
-  fetched_at    TEXT NOT NULL,
-  UNIQUE(platform, post_id, metric_date)
-);
-
-CREATE TABLE IF NOT EXISTS follower_snapshots (
-  id            INTEGER PRIMARY KEY AUTOINCREMENT,
-  platform      TEXT NOT NULL,
-  follower_count INTEGER NOT NULL,
-  snapshot_date TEXT NOT NULL,
-  UNIQUE(platform, snapshot_date)
-);
-
-CREATE INDEX IF NOT EXISTS idx_metrics_platform_date ON engagement_metrics(platform, metric_date);
-CREATE INDEX IF NOT EXISTS idx_metrics_published ON engagement_metrics(published_at);
-
--- Marketing posts: tracks every post, video, and article published to any platform.
--- Used to prevent double-posting and to measure marketing effort over time.
-CREATE TABLE IF NOT EXISTS marketing_posts (
-  id            INTEGER PRIMARY KEY AUTOINCREMENT,
-  type          TEXT NOT NULL CHECK(type IN ('post','video','article','reply','thread')),
-  platform      TEXT NOT NULL,
-  account_id    TEXT,
-  post_id       TEXT,
-  post_url      TEXT,
-  title         TEXT,
-  content_hash  TEXT NOT NULL,
-  published_at  TEXT NOT NULL,
-  status        TEXT NOT NULL DEFAULT 'published' CHECK(status IN ('published','failed','skipped','draft')),
-  tags          TEXT,            -- JSON array
-  campaign      TEXT,            -- e.g. 'v1.4.1-launch', 'weekly-stats'
-  extra_json    TEXT,            -- arbitrary metadata
-  UNIQUE(platform, content_hash)
-);
-
-CREATE INDEX IF NOT EXISTS idx_mktg_platform_published ON marketing_posts(platform, published_at);
-CREATE INDEX IF NOT EXISTS idx_mktg_campaign ON marketing_posts(campaign);
-CREATE INDEX IF NOT EXISTS idx_mktg_type ON marketing_posts(type);