@stackmemoryai/stackmemory 0.3.16 → 0.3.18

package/scripts/linear-task-review.js

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import dotenv from 'dotenv';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+dotenv.config({ 
+  path: path.join(__dirname, '..', '.env'),
+  silent: true
+});
+
+async function queryLinear(query, variables = {}) {
+  const response = await fetch('https://api.linear.app/graphql', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': process.env.LINEAR_API_KEY
+    },
+    body: JSON.stringify({ query, variables })
+  });
+
+  const data = await response.json();
+  if (data.errors) {
+    throw new Error(data.errors[0].message);
+  }
+  return data.data;
+}
+
+async function reviewTasks() {
+  console.log('📋 LINEAR TASK REVIEW\n' + '='.repeat(50));
+  
+  try {
+    // Get viewer info
+    const viewerData = await queryLinear(`
+      query {
+        viewer {
+          name
+          email
+        }
+      }
+    `);
+    
+    console.log(`👤 Logged in as: ${viewerData.viewer.name || viewerData.viewer.email}\n`);
+    
+    // Get all active issues
+    const issuesData = await queryLinear(`
+      query {
+        issues(
+          filter: {
+            state: { type: { in: ["started", "unstarted"] } }
+          }
+          orderBy: updatedAt
+          first: 100
+        ) {
+          nodes {
+            identifier
+            title
+            priority
+            priorityLabel
+            createdAt
+            updatedAt
+            state {
+              name
+              type
+            }
+            assignee {
+              name
+              email
+            }
+            labels {
+              nodes {
+                name
+                color
+              }
+            }
+            estimate
+            url
+          }
+        }
+      }
+    `);
+    
+    const issues = issuesData.issues.nodes;
+    
+    // Group by state
+    const byState = {};
+    issues.forEach(issue => {
+      const stateName = issue.state.name;
+      if (!byState[stateName]) byState[stateName] = [];
+      byState[stateName].push(issue);
+    });
+    
+    // Priority mapping
+    const priorityLabels = {
+      0: '🔴 No Priority',
+      1: '🔴 Urgent',
+      2: '🟠 High',
+      3: '🟡 Medium',
+      4: '🔵 Low'
+    };
+    
+    // Display by state
+    const stateOrder = ['In Progress', 'Todo', 'Triage', 'Backlog'];
+    
+    stateOrder.forEach(state => {
+      if (byState[state] && byState[state].length > 0) {
+        console.log(`\n📊 ${state.toUpperCase()} (${byState[state].length} tasks)`);
+        console.log('-'.repeat(50));
+        
+        byState[state]
+          .sort((a, b) => (a.priority || 5) - (b.priority || 5))
+          .slice(0, 10)
+          .forEach(issue => {
+            const priority = priorityLabels[issue.priority] || '⚪ None';
+            const assignee = issue.assignee ? `👤 ${issue.assignee.name}` : '👤 Unassigned';
+            const labels = issue.labels.nodes.map(l => l.name).join(', ');
+            const labelStr = labels ? ` [${labels}]` : '';
+            
+            console.log(`\n  ${issue.identifier}: ${issue.title}`);
+            console.log(`    ${priority} | ${assignee}${labelStr}`);
+            console.log(`    📎 ${issue.url}`);
+          });
+          
+        if (byState[state].length > 10) {
+          console.log(`\n  ... and ${byState[state].length - 10} more tasks`);
+        }
+      }
+    });
+    
+    // Summary statistics
+    console.log('\n' + '='.repeat(50));
+    console.log('📈 SUMMARY STATISTICS\n');
+    
+    const inProgress = byState['In Progress']?.length || 0;
+    const todo = byState['Todo']?.length || 0;
+    const triage = byState['Triage']?.length || 0;
+    const backlog = byState['Backlog']?.length || 0;
+    
+    console.log(`  🏃 In Progress: ${inProgress}`);
+    console.log(`  📝 Todo: ${todo}`);
+    console.log(`  🔍 Triage: ${triage}`);
+    console.log(`  📦 Backlog: ${backlog}`);
+    console.log(`  📊 Total Active: ${issues.length}`);
+    
+    // High priority items
+    const urgent = issues.filter(i => i.priority === 1);
+    const high = issues.filter(i => i.priority === 2);
+    
+    if (urgent.length > 0) {
+      console.log('\n🚨 URGENT PRIORITY TASKS:');
+      urgent.forEach(issue => {
+        const state = issue.state.name;
+        const assignee = issue.assignee?.name || 'Unassigned';
+        console.log(`  • ${issue.identifier}: ${issue.title} [${state}] - ${assignee}`);
+      });
+    }
+    
+    if (high.length > 0) {
+      console.log('\n🔥 HIGH PRIORITY TASKS:');
+      high.slice(0, 5).forEach(issue => {
+        const state = issue.state.name;
+        const assignee = issue.assignee?.name || 'Unassigned';
+        console.log(`  • ${issue.identifier}: ${issue.title} [${state}] - ${assignee}`);
+      });
+    }
+    
+    // Recommendations
+    console.log('\n' + '='.repeat(50));
+    console.log('💡 RECOMMENDED NEXT ACTIONS:\n');
+    
+    // Find tasks to work on
+    const recommendations = [];
+    
+    // 1. In-progress tasks that need completion
+    const myInProgress = issues.filter(i => 
+      i.state.name === 'In Progress' && 
+      (!i.assignee || i.assignee.name === viewerData.viewer.name)
+    );
+    
+    if (myInProgress.length > 0) {
+      recommendations.push({
+        reason: '🏃 Continue in-progress work',
+        tasks: myInProgress.slice(0, 2)
+      });
+    }
+    
+    // 2. High priority unassigned todos
+    const highPriorityTodos = issues.filter(i => 
+      i.state.name === 'Todo' && 
+      i.priority <= 2 &&
+      !i.assignee
+    );
+    
+    if (highPriorityTodos.length > 0) {
+      recommendations.push({
+        reason: '🔥 High priority unassigned tasks',
+        tasks: highPriorityTodos.slice(0, 2)
+      });
+    }
+    
+    // 3. Any todo tasks
+    const todoTasks = issues.filter(i => 
+      i.state.name === 'Todo' &&
+      !i.assignee
+    );
+    
+    if (todoTasks.length > 0 && recommendations.length < 2) {
+      recommendations.push({
+        reason: '📝 Available todo tasks',
+        tasks: todoTasks.slice(0, 2)
+      });
+    }
+    
+    if (recommendations.length > 0) {
+      recommendations.forEach(rec => {
+        console.log(rec.reason);
+        rec.tasks.forEach(task => {
+          const priority = priorityLabels[task.priority] || '⚪ None';
+          console.log(`  └─ ${task.identifier}: ${task.title}`);
+          console.log(`     ${priority} | ${task.url}`);
+        });
+        console.log('');
+      });
+    } else {
+      console.log('✅ No immediate tasks requiring attention');
+    }
+    
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    process.exit(1);
+  }
+}
+
+reviewTasks();

package/scripts/list-linear-tasks.ts

@@ -0,0 +1,178 @@
+#!/usr/bin/env ts-node
+
+/**
+ * Standalone script to list all Linear tasks grouped by status
+ */
+
+import { LinearClient } from '../src/integrations/linear/client.js';
+import { LinearAuthManager } from '../src/integrations/linear/auth.js';
+import chalk from 'chalk';
+// Type-safe environment variable access
+function getEnv(key: string, defaultValue?: string): string {
+  const value = process.env[key];
+  if (value === undefined) {
+    if (defaultValue !== undefined) return defaultValue;
+    throw new Error(`Environment variable ${key} is required`);
+  }
+  return value;
+}
+
+function getOptionalEnv(key: string): string | undefined {
+  return process.env[key];
+}
+
+interface TasksByStatus {
+  [status: string]: Array<{
+    identifier: string;
+    title: string;
+    priority: number;
+    assignee?: string;
+    url: string;
+  }>;
+}
+
+async function main() {
+  try {
+    console.log(chalk.cyan('🔍 Fetching Linear tasks...\n'));
+
+    // Try to get authentication
+    const authManager = new LinearAuthManager(process.cwd());
+    const tokens = authManager.loadTokens();
+    const apiKey = process.env['LINEAR_API_KEY'];
+
+    if (!tokens && !apiKey) {
+      console.log(chalk.red('❌ Not authenticated with Linear'));
+      console.log('Run: node dist/src/cli/index.js linear setup');
+      process.exit(1);
+    }
+
+    // Create client
+    const client = apiKey
+      ? new LinearClient({ apiKey })
+      : new LinearClient({
+          apiKey: tokens?.accessToken ?? '',
+          useBearer: true,
+        });
+
+    // Get all issues (increase limit to get more tasks)
+    console.log(chalk.gray('Fetching issues...'));
+    const issues = await client.getIssues({ limit: 200 });
+
+    if (!issues || issues.length === 0) {
+      console.log(chalk.gray('No issues found'));
+      return;
+    }
+
+    console.log(chalk.green(`✓ Found ${issues.length} tasks`));
+
+    // Group tasks by status
+    const tasksByStatus: TasksByStatus = {};
+
+    issues.forEach((issue) => {
+      const statusType = issue.state.type;
+      const statusName = issue.state.name;
+      const key = `${statusType} (${statusName})`;
+
+      if (!tasksByStatus[key]) {
+        tasksByStatus[key] = [];
+      }
+
+      tasksByStatus[key].push({
+        identifier: issue.identifier,
+        title: issue.title,
+        priority: issue.priority,
+        assignee: issue.assignee?.name,
+        url: issue.url,
+      });
+    });
+
+    // Define status order for display
+    const statusOrder = [
+      'backlog',
+      'unstarted',
+      'started',
+      'completed',
+      'cancelled',
+    ];
+
+    // Display results grouped by status
+    console.log(chalk.cyan('\n📋 Linear Tasks by Status:\n'));
+
+    statusOrder.forEach((statusType) => {
+      // Find all status keys that match this type
+      const matchingKeys = Object.keys(tasksByStatus).filter((key) =>
+        key.startsWith(statusType)
+      );
+
+      matchingKeys.forEach((statusKey) => {
+        const tasks = tasksByStatus[statusKey];
+        if (tasks.length === 0) return;
+
+        // Status header with count
+        console.log(
+          chalk.bold.white(
+            `\n${getStatusEmoji(statusType)} ${statusKey} (${tasks.length} tasks)`
+          )
+        );
+        console.log(chalk.gray(''.padEnd(60, '─')));
+
+        // List tasks
+        tasks.forEach((task) => {
+          const priorityStr =
+            task.priority > 0
+              ? chalk.yellow(`P${task.priority}`)
+              : chalk.gray('--');
+          const assigneeStr = task.assignee
+            ? chalk.blue(task.assignee)
+            : chalk.gray('Unassigned');
+          const titleStr =
+            task.title.length > 50
+              ? task.title.substring(0, 47) + '...'
+              : task.title;
+
+          console.log(
+            `  ${chalk.cyan(task.identifier.padEnd(8))} ${titleStr.padEnd(50)} ${priorityStr.padEnd(8)} ${assigneeStr}`
+          );
+        });
+      });
+    });
+
+    // Summary
+    const totalTasks = issues.length;
+    const statusCounts = Object.entries(tasksByStatus).map(
+      ([status, tasks]) => ({
+        status,
+        count: tasks.length,
+      })
+    );
+
+    console.log(chalk.cyan('\n📊 Summary:'));
+    statusCounts.forEach(({ status, count }) => {
+      console.log(chalk.gray(`  ${status}: ${count} tasks`));
+    });
+    console.log(chalk.bold(`  Total: ${totalTasks} tasks`));
+  } catch (error: unknown) {
+    console.error(chalk.red('❌ Error:'), (error as Error).message);
+    process.exit(1);
+  }
+}
+
+function getStatusEmoji(statusType: string): string {
+  switch (statusType) {
+    case 'backlog':
+      return '📋';
+    case 'unstarted':
+      return '📝';
+    case 'started':
+      return '⏳';
+    case 'completed':
+      return '✅';
+    case 'cancelled':
+      return '❌';
+    default:
+      return '📄';
+  }
+}
+
+// Direct execution
+main();

package/scripts/mcp-proxy.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+/**
+ * MCP Proxy for Railway-hosted StackMemory
+ * Bridges Claude Desktop to Railway API
+ */
+
+import https from 'https';
+
+const RAILWAY_URL = process.env.RAILWAY_URL || 'https://stackmemory-production.up.railway.app';
+const API_KEY = process.env.API_KEY;
+
+if (!API_KEY) {
+  console.error('ERROR: API_KEY environment variable is required');
+  process.exit(1);
+}
+
+// Simple proxy that forwards MCP requests to Railway
+process.stdin.on('data', async (data) => {
+  try {
+    const request = JSON.parse(data.toString());
+    
+    // Forward to Railway API
+    const response = await makeRequest('/api/tools/execute', {
+      tool: request.method,
+      params: request.params
+    });
+    
+    // Send response back to Claude
+    process.stdout.write(JSON.stringify(response) + '\n');
+  } catch (error) {
+    process.stderr.write(`Error: ${error.message}\n`);
+  }
+});
+
+async function makeRequest(path, body) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(path, RAILWAY_URL);
+    
+    const options = {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${API_KEY}`,
+        'Content-Type': 'application/json'
+      }
+    };
+    
+    const req = https.request(url, options, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(data));
+        } catch (e) {
+          resolve({ error: data });
+        }
+      });
+    });
+    
+    req.on('error', reject);
+    req.write(JSON.stringify(body));
+    req.end();
+  });
+}
+
+console.error('StackMemory Railway MCP Proxy started');
+console.error(`Connected to: ${RAILWAY_URL}`);

package/scripts/opencode-wrapper.sh

@@ -0,0 +1,85 @@
+#!/bin/bash
+
+# OpenCode wrapper with StackMemory integration
+# Usage: Add alias to ~/.zshrc: alias opencode-sm='~/Dev/stackmemory/scripts/opencode-wrapper.sh'
+
+# Check for auto-sync flag
+AUTO_SYNC=false
+SYNC_INTERVAL=5
+for arg in "$@"; do
+    case $arg in
+        --auto-sync)
+            AUTO_SYNC=true
+            shift
+            ;;
+        --sync-interval=*)
+            SYNC_INTERVAL="${arg#*=}"
+            shift
+            ;;
+    esac
+done
+
+# Auto-initialize StackMemory if in git repo without it
+if [ -d ".git" ] && [ ! -d ".stackmemory" ]; then
+    echo "📦 Initializing StackMemory for this project..."
+    stackmemory init --silent 2>/dev/null || true
+fi
+
+# Load existing context if available
+if [ -d ".stackmemory" ]; then
+    echo "🧠 Loading StackMemory context..."
+    stackmemory status --brief 2>/dev/null || true
+fi
+
+# Start Linear auto-sync in background if requested
+SYNC_PID=""
+if [ "$AUTO_SYNC" = true ] && [ -n "$LINEAR_API_KEY" ]; then
+    echo "🔄 Starting Linear auto-sync (${SYNC_INTERVAL}min intervals)..."
+    (
+        while true; do
+            sleep $((SYNC_INTERVAL * 60))
+            if [ -d ".stackmemory" ]; then
+                stackmemory linear sync --quiet 2>/dev/null || true
+            fi
+        done
+    ) &
+    SYNC_PID=$!
+fi
+
+cleanup() {
+    echo ""
+    echo "📝 Saving StackMemory context..."
+    
+    # Kill auto-sync if running
+    if [ -n "$SYNC_PID" ] && kill -0 $SYNC_PID 2>/dev/null; then
+        echo "🛑 Stopping auto-sync..."
+        kill $SYNC_PID 2>/dev/null || true
+    fi
+    
+    # Check if in a git repo with stackmemory
+    if [ -d ".stackmemory" ]; then
+        # Save current context
+        stackmemory status 2>/dev/null
+        
+        # If Linear API key is set, final sync
+        if [ -n "$LINEAR_API_KEY" ]; then
+            echo "🔄 Final Linear sync..."
+            stackmemory linear sync 2>/dev/null
+        fi
+        
+        echo "✅ StackMemory context saved"
+    fi
+}
+
+# Set trap for exit signals
+trap cleanup EXIT INT TERM
+
+# Run OpenCode
+if command -v opencode &> /dev/null; then
+    opencode "$@"
+else
+    echo "❌ OpenCode not found. Please install it first."
+    echo "   Run: curl -fsSL https://opencode.ai/install | bash"
+    echo "   Or:  npm install -g opencode-ai"
+    exit 1
+fi

package/scripts/publish-local.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+/**
+ * Local NPM Publishing Script with Token
+ * Usage: node scripts/publish-local.js
+ * 
+ * Requires NPM_TOKEN in environment or .env file
+ */
+
+import { execSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+
+// Load .env file if it exists
+const envPath = join(process.cwd(), '.env');
+if (existsSync(envPath)) {
+  const envContent = readFileSync(envPath, 'utf-8');
+  envContent.split('\n').forEach(line => {
+    const [key, value] = line.split('=');
+    if (key && value && !process.env[key]) {
+      process.env[key.trim()] = value.trim();
+    }
+  });
+}
+
+// Check for NPM token
+const npmToken = process.env.NPM_TOKEN;
+if (!npmToken) {
+  console.error(chalk.red('❌ NPM_TOKEN not found'));
+  console.log(chalk.yellow('Please set NPM_TOKEN environment variable:'));
+  console.log(chalk.gray('  export NPM_TOKEN=npm_xxx...'));
+  console.log(chalk.gray('  Or create a .env file with NPM_TOKEN=npm_xxx...'));
+  console.log();
+  console.log(chalk.yellow('Get your token from:'));
+  console.log(chalk.blue('  https://www.npmjs.com/settings/YOUR_USERNAME/tokens'));
+  process.exit(1);
+}
+
+// Create .npmrc with token
+const npmrcContent = `//registry.npmjs.org/:_authToken=${npmToken}
+registry=https://registry.npmjs.org/
+access=public
+`;
+
+console.log(chalk.green('📝 Setting up NPM authentication...'));
+execSync(`echo "${npmrcContent}" > ~/.npmrc`);
+
+try {
+  // Check current version
+  console.log(chalk.yellow('📦 Current package info:'));
+  execSync('npm view @stackmemoryai/stackmemory version', { stdio: 'inherit' });
+  
+  // Build
+  console.log(chalk.yellow('\n🔨 Building package...'));
+  execSync('npm run build', { stdio: 'inherit' });
+  
+  // Publish
+  console.log(chalk.yellow('\n🚀 Publishing to NPM...'));
+  execSync('npm publish --access public', { stdio: 'inherit' });
+  
+  console.log(chalk.green('\n✅ Successfully published to NPM!'));
+  
+  // Show new version
+  console.log(chalk.yellow('\n📦 New package info:'));
+  execSync('npm view @stackmemoryai/stackmemory version', { stdio: 'inherit' });
+  
+} catch (error) {
+  console.error(chalk.red('\n❌ Publishing failed:'), error.message);
+  process.exit(1);
+} finally {
+  // Clean up .npmrc (optional, for security)
+  console.log(chalk.gray('\n🧹 Cleaning up credentials...'));
+  execSync('rm ~/.npmrc 2>/dev/null || true');
+}