thumbgate 0.9.14 → 1.1.0

package/scripts/social-analytics/store.js

@@ -2,11 +2,209 @@
 
 const path = require('path');
 const fs = require('fs');
-const Database = require('better-sqlite3');
+let Database = null;
+try {
+  Database = require('better-sqlite3');
+} catch (_) {
+  Database = null;
+}
 
 const DEFAULT_DB_PATH = path.join(__dirname, 'db', 'social-analytics.db');
 const SCHEMA_PATH = path.join(__dirname, 'db', 'schema.sql');
 
+class MemoryStatement {
+  constructor(handler) {
+    this.handler = handler;
+  }
+
+  run(params) {
+    return this.handler.run(params);
+  }
+
+  all(params) {
+    return this.handler.all(params);
+  }
+}
+
+class MemoryDatabase {
+  constructor() {
+    this.tables = {
+      engagement_metrics: [],
+      follower_snapshots: [],
+    };
+  }
+
+  pragma() {}
+
+  exec() {}
+
+  close() {}
+
+  prepare(sql) {
+    const normalized = sql.replace(/\s+/g, ' ').trim();
+
+    if (normalized.includes('INSERT OR REPLACE INTO engagement_metrics')) {
+      return new MemoryStatement({
+        run: (params) => {
+          const index = this.tables.engagement_metrics.findIndex(
+            (row) =>
+              row.platform === params.platform &&
+              row.post_id === params.post_id &&
+              row.metric_date === params.metric_date
+          );
+          const row = { ...params };
+          if (index >= 0) {
+            this.tables.engagement_metrics[index] = row;
+          } else {
+            this.tables.engagement_metrics.push(row);
+          }
+          return { changes: 1 };
+        },
+      });
+    }
+
+    if (normalized.includes('INSERT OR REPLACE INTO follower_snapshots')) {
+      return new MemoryStatement({
+        run: (params) => {
+          const index = this.tables.follower_snapshots.findIndex(
+            (row) => row.platform === params.platform && row.snapshot_date === params.snapshot_date
+          );
+          const row = { ...params };
+          if (index >= 0) {
+            this.tables.follower_snapshots[index] = row;
+          } else {
+            this.tables.follower_snapshots.push(row);
+          }
+          return { changes: 1 };
+        },
+      });
+    }
+
+    if (normalized.includes('SELECT * FROM engagement_metrics WHERE platform = ?')) {
+      return new MemoryStatement({
+        all: (platform) =>
+          this.tables.engagement_metrics.filter((row) => row.platform === platform),
+      });
+    }
+
+    const literalPlatformMatch = normalized.match(
+      /^SELECT \* FROM engagement_metrics WHERE platform = '([^']+)'$/i
+    );
+    if (literalPlatformMatch) {
+      const [, platform] = literalPlatformMatch;
+      return new MemoryStatement({
+        all: () =>
+          this.tables.engagement_metrics.filter((row) => row.platform === platform),
+      });
+    }
+
+    if (normalized.includes('FROM engagement_metrics') && normalized.includes('GROUP BY platform')) {
+      return new MemoryStatement({
+        all: (params = {}) => {
+          const rows = this.tables.engagement_metrics.filter((row) => {
+            if (row.metric_date < params.cutoff) return false;
+            if (params.platform && row.platform !== params.platform) return false;
+            return true;
+          });
+          const grouped = new Map();
+          for (const row of rows) {
+            const bucket = grouped.get(row.platform) || {
+              platform: row.platform,
+              post_count: 0,
+              total_impressions: 0,
+              total_reach: 0,
+              total_likes: 0,
+              total_comments: 0,
+              total_shares: 0,
+              total_saves: 0,
+              total_clicks: 0,
+              total_video_views: 0,
+              _postIds: new Set(),
+              _rows: 0,
+            };
+            bucket._postIds.add(row.post_id);
+            bucket.total_impressions += row.impressions || 0;
+            bucket.total_reach += row.reach || 0;
+            bucket.total_likes += row.likes || 0;
+            bucket.total_comments += row.comments || 0;
+            bucket.total_shares += row.shares || 0;
+            bucket.total_saves += row.saves || 0;
+            bucket.total_clicks += row.clicks || 0;
+            bucket.total_video_views += row.video_views || 0;
+            bucket._rows += 1;
+            grouped.set(row.platform, bucket);
+          }
+          return [...grouped.values()]
+            .map((bucket) => ({
+              platform: bucket.platform,
+              post_count: bucket._postIds.size,
+              total_impressions: bucket.total_impressions,
+              total_reach: bucket.total_reach,
+              total_likes: bucket.total_likes,
+              total_comments: bucket.total_comments,
+              total_shares: bucket.total_shares,
+              total_saves: bucket.total_saves,
+              total_clicks: bucket.total_clicks,
+              total_video_views: bucket.total_video_views,
+              avg_impressions: Number((bucket.total_impressions / bucket._rows).toFixed(2)),
+              avg_likes: Number((bucket.total_likes / bucket._rows).toFixed(2)),
+            }))
+            .sort((a, b) => b.total_impressions - a.total_impressions);
+        },
+      });
+    }
+
+    if (normalized.includes('FROM engagement_metrics') && normalized.includes('GROUP BY platform, post_id')) {
+      return new MemoryStatement({
+        all: ({ cutoff, limit }) => {
+          const rows = this.tables.engagement_metrics.filter((row) => row.metric_date >= cutoff);
+          const grouped = new Map();
+          for (const row of rows) {
+            const key = `${row.platform}::${row.post_id}`;
+            const bucket = grouped.get(key) || {
+              platform: row.platform,
+              content_type: row.content_type,
+              post_id: row.post_id,
+              post_url: row.post_url ?? null,
+              published_at: row.published_at ?? null,
+              total_engagement: 0,
+              total_impressions: 0,
+              total_likes: 0,
+              total_comments: 0,
+              total_shares: 0,
+              total_saves: 0,
+              total_video_views: 0,
+            };
+            bucket.total_engagement +=
+              (row.likes || 0) + (row.comments || 0) + (row.shares || 0) + (row.saves || 0);
+            bucket.total_impressions += row.impressions || 0;
+            bucket.total_likes += row.likes || 0;
+            bucket.total_comments += row.comments || 0;
+            bucket.total_shares += row.shares || 0;
+            bucket.total_saves += row.saves || 0;
+            bucket.total_video_views += row.video_views || 0;
+            grouped.set(key, bucket);
+          }
+          return [...grouped.values()]
+            .sort((a, b) => b.total_engagement - a.total_engagement)
+            .slice(0, limit);
+        },
+      });
+    }
+
+    if (normalized.includes('FROM follower_snapshots')) {
+      return new MemoryStatement({
+        all: ({ platform, cutoff }) =>
+          this.tables.follower_snapshots
+            .filter((row) => row.platform === platform && row.snapshot_date >= cutoff)
+            .sort((a, b) => a.snapshot_date.localeCompare(b.snapshot_date)),
+      });
+    }
+
+    throw new Error(`MemoryDatabase does not support query: ${normalized}`);
+  }
+}
+
 /**
  * Opens the SQLite database, applies the schema, and returns the db instance.
  * Idempotent — safe to call multiple times; schema uses IF NOT EXISTS guards.
@@ -23,7 +221,7 @@ function initDb(dbPath = DEFAULT_DB_PATH) {
     fs.mkdirSync(dir, { recursive: true });
   }
 
-  const db = new Database(resolvedPath);
+  const db = Database ? new Database(resolvedPath) : new MemoryDatabase();
   db.pragma('busy_timeout = 3000');
 
   // Enable WAL mode for better concurrent read performance.

package/scripts/sync-version.js

@@ -18,6 +18,7 @@ const fs = require('fs');
 const path = require('path');
 
 const PROJECT_ROOT = path.join(__dirname, '..');
+const VERSION_PATTERN = '\\d+\\.\\d+\\.\\d+(?:-[0-9A-Za-z.-]+)?';
 
 function explicitPinnedServeArgs(version) {
   return ['--yes', '--package', `thumbgate@${version}`, 'thumbgate', 'serve'];
@@ -308,7 +309,7 @@ function syncVersion(opts) {
     'plugins/codex-profile/INSTALL.md',
     'plugins/opencode-profile/INSTALL.md',
   ];
-  const pinnedPackagePattern = /thumbgate@\d+\.\d+\.\d+/g;
+  const pinnedPackagePattern = new RegExp(`thumbgate@${VERSION_PATTERN}`, 'g');
   for (const relPath of pinnedPackageTargets) {
     const filePath = path.join(PROJECT_ROOT, relPath);
     if (!fs.existsSync(filePath)) continue;
@@ -329,7 +330,7 @@ function syncVersion(opts) {
   if (fs.existsSync(path.join(PROJECT_ROOT, landingPath))) {
     const landingContent = fs.readFileSync(path.join(PROJECT_ROOT, landingPath), 'utf-8');
     // Match any version pattern in the hero badge
-    const badgeMatch = landingContent.match(/v(\d+\.\d+\.\d+) — Hosted API/);
+    const badgeMatch = landingContent.match(new RegExp(`v(${VERSION_PATTERN}) — Hosted API`));
     if (badgeMatch && badgeMatch[1] !== version) {
       drifted.push({ file: landingPath, field: 'hero-badge', current: badgeMatch[1] });
       if (!checkOnly) {
@@ -337,7 +338,7 @@ function syncVersion(opts) {
       }
     }
     // JSON snippet version
-    const jsonMatch = landingContent.match(/"version"<\/span><span class="out">: <\/span><span class="val">"(\d+\.\d+\.\d+)"/);
+    const jsonMatch = landingContent.match(new RegExp(`"version"<\\/span><span class="out">: <\\/span><span class="val">"(${VERSION_PATTERN})"`));
     if (jsonMatch && jsonMatch[1] !== version) {
       drifted.push({ file: landingPath, field: 'json-snippet', current: jsonMatch[1] });
       if (!checkOnly) {
@@ -351,7 +352,7 @@ function syncVersion(opts) {
   const mcpSubmPath = 'docs/mcp-hub-submission.md';
   if (fs.existsSync(path.join(PROJECT_ROOT, mcpSubmPath))) {
     const mcpContent = fs.readFileSync(path.join(PROJECT_ROOT, mcpSubmPath), 'utf-8');
-    const versionMatch = mcpContent.match(/## Version\s+(\d+\.\d+\.\d+)/);
+    const versionMatch = mcpContent.match(new RegExp(`## Version\\s+(${VERSION_PATTERN})`));
     if (versionMatch && versionMatch[1] !== version) {
       drifted.push({ file: mcpSubmPath, field: 'version-heading', current: versionMatch[1] });
       if (!checkOnly) {
@@ -366,18 +367,18 @@ function syncVersion(opts) {
   if (fs.existsSync(path.join(PROJECT_ROOT, publicIndexPath))) {
     const publicIndexFile = path.join(PROJECT_ROOT, publicIndexPath);
     const publicContent = fs.readFileSync(publicIndexFile, 'utf-8');
-    const heroVersionMatch = publicContent.match(/New in v(\d+\.\d+\.\d+):?/);
+    const heroVersionMatch = publicContent.match(new RegExp(`New in v(${VERSION_PATTERN}):?`));
     if (heroVersionMatch && heroVersionMatch[1] !== version) {
       drifted.push({ file: publicIndexPath, field: 'hero-release-note', current: heroVersionMatch[1] });
       if (!checkOnly) {
         fs.writeFileSync(
           publicIndexFile,
-          publicContent.replace(/New in v\d+\.\d+\.\d+:?/, `New in v${version}`)
+          publicContent.replace(new RegExp(`New in v${VERSION_PATTERN}:?`), `New in v${version}`)
         );
       }
     }
 
-    const proofMatch = publicContent.match(/Versioned proof: v(\d+\.\d+\.\d+)/);
+    const proofMatch = publicContent.match(new RegExp(`Versioned proof: v(${VERSION_PATTERN})`));
     if (proofMatch && proofMatch[1] !== version) {
       drifted.push({ file: publicIndexPath, field: 'proof-pill', current: proofMatch[1] });
       if (!checkOnly) {
@@ -385,11 +386,17 @@ function syncVersion(opts) {
       }
     }
 
-    const footerMatch = publicContent.match(/Context Gateway • v(\d+\.\d+\.\d+)/);
+    const footerMatch = publicContent.match(new RegExp(`(?:Context Gateway|MIT License) [•·] v(${VERSION_PATTERN})`));
     if (footerMatch && footerMatch[1] !== version) {
       drifted.push({ file: publicIndexPath, field: 'footer-version', current: footerMatch[1] });
       if (!checkOnly) {
-        replaceInFile(publicIndexPath, `Context Gateway • v${footerMatch[1]}`, `Context Gateway • v${version}`);
+        fs.writeFileSync(
+          publicIndexFile,
+          publicContent.replace(
+            new RegExp(`((?:Context Gateway|MIT License) [•·] )v${VERSION_PATTERN}`),
+            `$1v${version}`
+          )
+        );
       }
     }
     targets.push(publicIndexPath);
@@ -400,13 +407,13 @@ function syncVersion(opts) {
   const serverStdioFile = path.join(PROJECT_ROOT, serverStdioPath);
   if (fs.existsSync(serverStdioFile)) {
     const serverStdioContent = fs.readFileSync(serverStdioFile, 'utf-8');
-    const serverInfoMatch = serverStdioContent.match(/version:\s*'(\d+\.\d+\.\d+)'/);
+    const serverInfoMatch = serverStdioContent.match(new RegExp(`version:\\s*'(${VERSION_PATTERN})'`));
     if (serverInfoMatch && serverInfoMatch[1] !== version) {
       drifted.push({ file: serverStdioPath, field: 'server-info-version', current: serverInfoMatch[1] });
       if (!checkOnly) {
         fs.writeFileSync(
           serverStdioFile,
-          serverStdioContent.replace(/version:\s*'\d+\.\d+\.\d+'/, `version: '${version}'`)
+          serverStdioContent.replace(new RegExp(`version:\\s*'${VERSION_PATTERN}'`), `version: '${version}'`)
         );
       }
     }

package/scripts/tool-registry.js

@@ -399,6 +399,17 @@ const TOOLS = [
       },
     },
   }),
+  destructiveTool({
+    name: 'export_hf_dataset',
+    description: 'Export ThumbGate agent traces and DPO preference pairs as a HuggingFace-compatible dataset. Produces traces.jsonl, preferences.jsonl, and dataset_info.json with PII-redacted paths. Ready for huggingface-cli upload.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        outputDir: { type: 'string', description: 'Output directory (default: feedback-dir/hf-dataset)' },
+        includeProvenance: { type: 'boolean', description: 'Include provenance events in traces (default: true)' },
+      },
+    },
+  }),
   destructiveTool({
     name: 'export_databricks_bundle',
     description: 'Export ThumbGate logs and proof artifacts as a Databricks-ready analytics bundle',
@@ -490,6 +501,21 @@ const TOOLS = [
       },
     },
   }),
+  readOnlyTool({
+    name: 'unified_context',
+    description: 'Assemble a complete, role-aware context object in one call. Combines session state, user profile, relevant lessons, prevention guards, context pack, and code-graph impact — with tiered graceful degradation (full → warm → cold). Replaces multiple recall/retrieve/session_primer calls with a single orchestrated request.',
+    inputSchema: {
+      type: 'object',
+      required: ['query'],
+      properties: {
+        query: { type: 'string', description: 'Describe the current task to find relevant context' },
+        toolName: { type: 'string', description: 'Current tool being invoked (improves lesson matching)' },
+        toolInput: { type: 'object', description: 'Current tool input (for guard evaluation)' },
+        agentType: { type: 'string', enum: ['claude', 'cursor', 'forgecode', 'codex'], description: 'Agent type — shapes context budget and feature inclusion' },
+        repoPath: { type: 'string', description: 'Repository path for code-graph impact analysis' },
+      },
+    },
+  }),
   destructiveTool({
     name: 'satisfy_gate',
     description: 'Satisfy a gate condition with optional structured reasoning. Evidence is stored with a 5-minute TTL. When structuredReasoning is provided, the premise/evidence/conclusion chain is stored in the audit trail.',
@@ -632,6 +658,28 @@ const TOOLS = [
       },
     },
   }),
+  readOnlyTool({
+    name: 'workflow_sentinel',
+    description: 'Predict pre-action workflow risk, blast radius, and remediations before a tool call executes.',
+    inputSchema: {
+      type: 'object',
+      required: ['toolName'],
+      properties: {
+        toolName: { type: 'string', description: 'Tool being assessed, such as Bash, Edit, or Write' },
+        command: { type: 'string', description: 'Optional shell command when toolName is Bash' },
+        filePath: { type: 'string', description: 'Optional primary file path for edit-like tools' },
+        changedFiles: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Optional affected-file list used to estimate blast radius',
+        },
+        repoPath: { type: 'string', description: 'Optional repository path used for git-aware integrity checks' },
+        baseBranch: { type: 'string', description: 'Optional protected base branch override (defaults to main)' },
+        requirePrForReleaseSensitive: { type: 'boolean', description: 'When true, release-sensitive changes on non-base branches require an open PR' },
+        requireVersionNotBehindBase: { type: 'boolean', description: 'When true, release-sensitive changes cannot lag behind the base branch package version' },
+      },
+    },
+  }),
   destructiveTool({
     name: 'register_claim_gate',
     description: 'Register a custom claim verification rule in local runtime state without editing tracked repo config.',

package/scripts/train_from_feedback.py

@@ -40,10 +40,6 @@ def resolve_feedback_dir() -> Path:
     if local_thumbgate.exists():
         return local_thumbgate
 
-    local_rlhf = PROJECT_ROOT / ".rlhf"
-    if local_rlhf.exists():
-        return local_rlhf
-
     local_legacy = PROJECT_ROOT / ".claude" / "memory" / "feedback"
     if local_legacy.exists():
         return local_legacy