@cpretzinger/boss-claude 1.0.0

package/lib/memory.js

@@ -0,0 +1,94 @@
+import { Octokit } from '@octokit/rest';
+import dotenv from 'dotenv';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { existsSync } from 'fs';
+import os from 'os';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Load environment variables from ~/.boss-claude/.env
+const envPath = join(os.homedir(), '.boss-claude', '.env');
+if (existsSync(envPath)) {
+  dotenv.config({ path: envPath });
+}
+
+let octokit = null;
+
+function getOctokit() {
+  if (!octokit) {
+    if (!process.env.GITHUB_TOKEN) {
+      throw new Error('GITHUB_TOKEN not found. Please run: boss-claude init');
+    }
+    octokit = new Octokit({ auth: process.env.GITHUB_TOKEN });
+  }
+  return octokit;
+}
+
+export async function saveMemory({ repo_name, summary, content, tags = [] }) {
+  const client = getOctokit();
+
+  const owner = process.env.GITHUB_OWNER || 'cpretzinger';
+  const repo = process.env.GITHUB_MEMORY_REPO || 'boss-claude-memory';
+
+  // Create issue with session data
+  const issue = await client.issues.create({
+    owner,
+    repo,
+    title: `[${repo_name}] ${summary}`,
+    body: `## Session Summary\n\n${summary}\n\n## Session Data\n\n\`\`\`json\n${content}\n\`\`\``,
+    labels: ['session', repo_name, ...tags]
+  });
+
+  return {
+    issue_number: issue.data.number,
+    url: issue.data.html_url,
+    summary,
+    tags
+  };
+}
+
+export async function searchMemory(query, limit = 5) {
+  const client = getOctokit();
+
+  const owner = process.env.GITHUB_OWNER || 'cpretzinger';
+  const repo = process.env.GITHUB_MEMORY_REPO || 'boss-claude-memory';
+
+  // Search issues
+  const { data } = await client.search.issuesAndPullRequests({
+    q: `repo:${owner}/${repo} ${query} label:session`,
+    sort: 'created',
+    order: 'desc',
+    per_page: limit
+  });
+
+  return data.items.map(issue => ({
+    title: issue.title,
+    summary: issue.body.split('\n\n')[1] || '',
+    url: issue.html_url,
+    created_at: issue.created_at,
+    labels: issue.labels.map(l => l.name)
+  }));
+}
+
+export async function getMemoryByIssue(issueNumber) {
+  const client = getOctokit();
+
+  const owner = process.env.GITHUB_OWNER || 'cpretzinger';
+  const repo = process.env.GITHUB_MEMORY_REPO || 'boss-claude-memory';
+
+  const { data } = await client.issues.get({
+    owner,
+    repo,
+    issue_number: issueNumber
+  });
+
+  return {
+    title: data.title,
+    body: data.body,
+    url: data.html_url,
+    created_at: data.created_at,
+    labels: data.labels.map(l => l.name)
+  };
+}

package/lib/postgres.js

@@ -0,0 +1,398 @@
+/**
+ * Boss Claude PostgreSQL Integration
+ * Railway Instance: turntable.proxy.rlwy.net:46272
+ * Database: railway
+ * Schema: boss_claude
+ */
+
+import pg from 'pg';
+const { Pool } = pg;
+
+// Connection pool for optimal performance
+// BOSS_CLAUDE_PG_URL must be set in environment variables
+const pool = new Pool({
+  connectionString: process.env.BOSS_CLAUDE_PG_URL,
+  max: 10,                    // Maximum connections
+  idleTimeoutMillis: 30000,   // Close idle connections after 30s
+  connectionTimeoutMillis: 2000,
+  // SSL configuration for Railway
+  ssl: {
+    rejectUnauthorized: false
+  }
+});
+
+// Handle pool errors
+pool.on('error', (err) => {
+  console.error('Unexpected PostgreSQL pool error:', err);
+});
+
+/**
+ * Session Management
+ */
+export const sessions = {
+  /**
+   * Start a new Boss Claude session
+   */
+  async start(userId, project, levelAtStart, contextData = {}) {
+    const query = `
+      INSERT INTO boss_claude.sessions (
+        user_id, project, level_at_start, context_data
+      ) VALUES ($1, $2, $3, $4)
+      RETURNING id, user_id, project, start_time, level_at_start
+    `;
+
+    const result = await pool.query(query, [
+      userId,
+      project,
+      levelAtStart,
+      JSON.stringify(contextData)
+    ]);
+
+    return result.rows[0];
+  },
+
+  /**
+   * Get current active session for user
+   */
+  async getCurrent(userId) {
+    const query = `
+      SELECT * FROM boss_claude.fn_get_current_session($1)
+    `;
+    const result = await pool.query(query, [userId]);
+    return result.rows[0] || null;
+  },
+
+  /**
+   * Update session progress
+   */
+  async updateProgress(sessionId, updates) {
+    const {
+      xpEarned = 0,
+      tokensSaved = 0,
+      tasksCompleted = 0,
+      perfectExecutions = 0,
+      efficiency = null,
+      contextData = null
+    } = updates;
+
+    let query = `
+      UPDATE boss_claude.sessions
+      SET
+        xp_earned = xp_earned + $2,
+        tokens_saved = tokens_saved + $3,
+        tasks_completed = tasks_completed + $4,
+        perfect_executions = perfect_executions + $5
+    `;
+
+    const params = [sessionId, xpEarned, tokensSaved, tasksCompleted, perfectExecutions];
+    let paramCount = 5;
+
+    if (efficiency !== null) {
+      paramCount++;
+      query += `, efficiency_multiplier = $${paramCount}`;
+      params.push(efficiency);
+    }
+
+    if (contextData !== null) {
+      paramCount++;
+      query += `, context_data = $${paramCount}`;
+      params.push(JSON.stringify(contextData));
+    }
+
+    query += `
+      WHERE id = $1
+      RETURNING id, xp_earned, tokens_saved, tasks_completed, perfect_executions, efficiency_multiplier
+    `;
+
+    const result = await pool.query(query, params);
+    return result.rows[0];
+  },
+
+  /**
+   * End a session
+   */
+  async end(sessionId, levelAtEnd, summary) {
+    const query = `
+      UPDATE boss_claude.sessions
+      SET
+        end_time = NOW(),
+        level_at_end = $2,
+        summary = $3
+      WHERE id = $1
+      RETURNING id, start_time, end_time, duration_seconds, xp_earned, tokens_saved
+    `;
+
+    const result = await pool.query(query, [sessionId, levelAtEnd, summary]);
+    return result.rows[0];
+  },
+
+  /**
+   * Get recent sessions
+   */
+  async getRecent(userId, limit = 10) {
+    const query = `
+      SELECT
+        id,
+        project,
+        start_time,
+        end_time,
+        duration_seconds,
+        xp_earned,
+        tokens_saved,
+        tasks_completed,
+        efficiency_multiplier,
+        summary
+      FROM boss_claude.sessions
+      WHERE user_id = $1
+      ORDER BY start_time DESC
+      LIMIT $2
+    `;
+
+    const result = await pool.query(query, [userId, limit]);
+    return result.rows;
+  }
+};
+
+/**
+ * Achievement Management
+ */
+export const achievements = {
+  /**
+   * Award an achievement
+   */
+  async award(userId, type, name, description, xpReward, metadata = {}) {
+    const query = `
+      INSERT INTO boss_claude.achievements (
+        user_id, achievement_type, achievement_name, description, xp_reward, metadata
+      ) VALUES ($1, $2, $3, $4, $5, $6)
+      RETURNING id, achievement_name, xp_reward, earned_at
+    `;
+
+    const result = await pool.query(query, [
+      userId,
+      type,
+      name,
+      description,
+      xpReward,
+      JSON.stringify(metadata)
+    ]);
+
+    return result.rows[0];
+  },
+
+  /**
+   * Get user achievements
+   */
+  async getAll(userId, limit = 50) {
+    const query = `
+      SELECT
+        id,
+        achievement_type,
+        achievement_name,
+        description,
+        xp_reward,
+        metadata,
+        earned_at
+      FROM boss_claude.achievements
+      WHERE user_id = $1
+      ORDER BY earned_at DESC
+      LIMIT $2
+    `;
+
+    const result = await pool.query(query, [userId, limit]);
+    return result.rows;
+  },
+
+  /**
+   * Check if user has specific achievement
+   */
+  async has(userId, achievementType) {
+    const query = `
+      SELECT EXISTS(
+        SELECT 1 FROM boss_claude.achievements
+        WHERE user_id = $1 AND achievement_type = $2
+      ) as has_achievement
+    `;
+
+    const result = await pool.query(query, [userId, achievementType]);
+    return result.rows[0].has_achievement;
+  }
+};
+
+/**
+ * Memory Snapshot Management
+ */
+export const snapshots = {
+  /**
+   * Create a memory snapshot
+   */
+  async create(userId, sessionId, type, data) {
+    const { level, tokenBank, totalXp, efficiency, snapshotData } = data;
+
+    const query = `
+      INSERT INTO boss_claude.memory_snapshots (
+        user_id, session_id, snapshot_type, snapshot_data,
+        level, token_bank, total_xp, efficiency
+      ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+      RETURNING id, snapshot_type, created_at
+    `;
+
+    const result = await pool.query(query, [
+      userId,
+      sessionId,
+      type,
+      JSON.stringify(snapshotData),
+      level,
+      tokenBank,
+      totalXp,
+      efficiency
+    ]);
+
+    return result.rows[0];
+  },
+
+  /**
+   * Get latest snapshot
+   */
+  async getLatest(userId) {
+    const query = `
+      SELECT
+        id,
+        snapshot_type,
+        snapshot_data,
+        level,
+        token_bank,
+        total_xp,
+        efficiency,
+        created_at
+      FROM boss_claude.memory_snapshots
+      WHERE user_id = $1
+      ORDER BY created_at DESC
+      LIMIT 1
+    `;
+
+    const result = await pool.query(query, [userId]);
+    return result.rows[0] || null;
+  }
+};
+
+/**
+ * Stats and Analytics
+ */
+export const stats = {
+  /**
+   * Get user statistics summary
+   */
+  async getSummary(userId) {
+    const query = `SELECT * FROM boss_claude.fn_get_user_stats($1)`;
+    const result = await pool.query(query, [userId]);
+    return result.rows[0];
+  },
+
+  /**
+   * Get session activity over time
+   */
+  async getActivity(userId, days = 30) {
+    const query = `
+      SELECT
+        DATE(start_time) as date,
+        COUNT(*) as sessions,
+        SUM(xp_earned) as total_xp,
+        SUM(tokens_saved) as total_tokens,
+        ROUND(AVG(efficiency_multiplier), 2) as avg_efficiency
+      FROM boss_claude.sessions
+      WHERE user_id = $1
+        AND start_time >= NOW() - INTERVAL '1 day' * $2
+      GROUP BY DATE(start_time)
+      ORDER BY date DESC
+    `;
+
+    const result = await pool.query(query, [userId, days]);
+    return result.rows;
+  },
+
+  /**
+   * Get top performing sessions
+   */
+  async getTopSessions(userId, limit = 5) {
+    const query = `
+      SELECT
+        project,
+        start_time,
+        xp_earned,
+        tokens_saved,
+        efficiency_multiplier,
+        tasks_completed,
+        summary
+      FROM boss_claude.sessions
+      WHERE user_id = $1
+        AND end_time IS NOT NULL
+      ORDER BY xp_earned DESC
+      LIMIT $2
+    `;
+
+    const result = await pool.query(query, [userId, limit]);
+    return result.rows;
+  }
+};
+
+/**
+ * Utility functions
+ */
+export const utils = {
+  /**
+   * Test database connection
+   */
+  async testConnection() {
+    try {
+      const result = await pool.query('SELECT NOW() as current_time, version()');
+      return {
+        connected: true,
+        timestamp: result.rows[0].current_time,
+        version: result.rows[0].version
+      };
+    } catch (error) {
+      return {
+        connected: false,
+        error: error.message
+      };
+    }
+  },
+
+  /**
+   * Get database stats
+   */
+  async getDatabaseStats() {
+    const query = `
+      SELECT
+        schemaname,
+        tablename,
+        pg_size_pretty(pg_total_relation_size(schemaname||'.'||tablename)) as total_size,
+        (SELECT COUNT(*) FROM boss_claude.sessions WHERE tablename = 'sessions') as sessions_count,
+        (SELECT COUNT(*) FROM boss_claude.achievements WHERE tablename = 'achievements') as achievements_count,
+        (SELECT COUNT(*) FROM boss_claude.memory_snapshots WHERE tablename = 'memory_snapshots') as snapshots_count
+      FROM pg_tables
+      WHERE schemaname = 'boss_claude'
+      ORDER BY tablename
+    `;
+
+    const result = await pool.query(query);
+    return result.rows;
+  },
+
+  /**
+   * Close connection pool (for graceful shutdown)
+   */
+  async close() {
+    await pool.end();
+  }
+};
+
+export default {
+  sessions,
+  achievements,
+  snapshots,
+  stats,
+  utils,
+  pool
+};

package/lib/session.js

@@ -0,0 +1,158 @@
+import Redis from 'ioredis';
+import dotenv from 'dotenv';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { existsSync } from 'fs';
+import os from 'os';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { saveMemory } from './memory.js';
+import { addXP, addTokens, incrementSessions } from './identity.js';
+
+const execAsync = promisify(exec);
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Load environment variables from ~/.boss-claude/.env
+const envPath = join(os.homedir(), '.boss-claude', '.env');
+if (existsSync(envPath)) {
+  dotenv.config({ path: envPath });
+}
+
+let redis = null;
+
+function getRedis() {
+  if (!redis) {
+    if (!process.env.REDIS_URL) {
+      throw new Error('REDIS_URL not found. Please run: boss-claude init');
+    }
+    redis = new Redis(process.env.REDIS_URL);
+  }
+  return redis;
+}
+
+async function getCurrentRepo() {
+  try {
+    const { stdout: repoPath } = await execAsync('git rev-parse --show-toplevel');
+    const { stdout: repoUrl } = await execAsync('git config --get remote.origin.url');
+
+    const repoName = repoUrl.trim().split('/').pop().replace('.git', '');
+
+    return {
+      name: repoName,
+      path: repoPath.trim(),
+      url: repoUrl.trim()
+    };
+  } catch (error) {
+    return null;
+  }
+}
+
+export async function loadSession() {
+  const repo = await getCurrentRepo();
+
+  if (!repo) {
+    return null;
+  }
+
+  const client = getRedis();
+  const sessionKey = `boss:session:${repo.name}:current`;
+
+  const data = await client.get(sessionKey);
+
+  if (!data) {
+    return {
+      repo,
+      started_at: new Date().toISOString(),
+      messages: [],
+      tokens_used: 0
+    };
+  }
+
+  return {
+    ...JSON.parse(data),
+    repo
+  };
+}
+
+export async function saveSession(summary, tags) {
+  const repo = await getCurrentRepo();
+
+  if (!repo) {
+    throw new Error('Not in a git repository');
+  }
+
+  const client = getRedis();
+  const sessionKey = `boss:session:${repo.name}:current`;
+
+  const sessionData = await client.get(sessionKey);
+  const session = sessionData ? JSON.parse(sessionData) : {
+    started_at: new Date().toISOString(),
+    messages: [],
+    tokens_used: 0
+  };
+
+  // Save to GitHub Issues
+  const memory = await saveMemory({
+    repo_name: repo.name,
+    summary: summary || 'Session saved',
+    content: JSON.stringify(session, null, 2),
+    tags: tags ? tags.split(',').map(t => t.trim()) : []
+  });
+
+  // Calculate rewards
+  const xpEarned = 50; // Base XP per session
+  const tokensEarned = session.tokens_used || 0;
+
+  await addXP(xpEarned);
+  await addTokens(tokensEarned);
+  await incrementSessions();
+
+  // Update repo stats
+  const repoKey = `boss:repo:${repo.name}`;
+  const repoData = await client.get(repoKey);
+  const repoStats = repoData ? JSON.parse(repoData) : {
+    name: repo.name,
+    path: repo.path,
+    session_count: 0,
+    first_seen: new Date().toISOString()
+  };
+
+  repoStats.session_count++;
+  repoStats.last_active = new Date().toISOString();
+
+  await client.set(repoKey, JSON.stringify(repoStats));
+
+  // Clear current session
+  await client.del(sessionKey);
+
+  return {
+    ...memory,
+    repo_name: repo.name,
+    xp_earned: xpEarned,
+    tokens_earned: tokensEarned
+  };
+}
+
+export async function updateSessionTokens(tokens) {
+  const repo = await getCurrentRepo();
+
+  if (!repo) {
+    return;
+  }
+
+  const client = getRedis();
+  const sessionKey = `boss:session:${repo.name}:current`;
+
+  const data = await client.get(sessionKey);
+  const session = data ? JSON.parse(data) : {
+    started_at: new Date().toISOString(),
+    messages: [],
+    tokens_used: 0
+  };
+
+  session.tokens_used = (session.tokens_used || 0) + tokens;
+
+  await client.set(sessionKey, JSON.stringify(session));
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@cpretzinger/boss-claude",
+  "version": "1.0.0",
+  "description": "Boss Claude - Gamified AI assistant with persistent memory across all repos",
+  "type": "module",
+  "bin": {
+    "boss-claude": "bin/boss-claude.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/install.js"
+  },
+  "keywords": [
+    "claude",
+    "ai",
+    "assistant",
+    "cli",
+    "memory",
+    "gamification"
+  ],
+  "author": "Craig Pretzinger <craig@example.com>",
+  "license": "MIT",
+  "dependencies": {
+    "ioredis": "^5.3.2",
+    "@octokit/rest": "^20.0.2",
+    "pg": "^8.11.3",
+    "dotenv": "^16.3.1",
+    "commander": "^11.1.0",
+    "chalk": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cpretzinger/boss-claude.git"
+  }
+}