swarm-tickets 2.0.3 → 2.1.0

package/README.md

@@ -199,6 +199,46 @@ CREATE INDEX IF NOT EXISTS idx_swarm_actions_ticket_id ON swarm_actions(ticket_i
 CREATE INDEX IF NOT EXISTS idx_comments_ticket_id ON comments(ticket_id);
 ```
 
+## 🔄 Migrating Existing Tickets
+
+Already have tickets in JSON and want to switch to SQLite or Supabase? Use the migration tool:
+
+### Migrate to SQLite
+
+```bash
+# Install SQLite dependency
+npm install better-sqlite3
+
+# Run migration
+npx swarm-tickets migrate --to sqlite
+```
+
+### Migrate to Supabase
+
+```bash
+# Install Supabase dependency
+npm install @supabase/supabase-js
+
+# Set environment variables
+export SUPABASE_URL=https://your-project.supabase.co
+export SUPABASE_ANON_KEY=your-anon-key
+
+# Run migration (create tables first - see Supabase setup above)
+npx swarm-tickets migrate --to supabase
+```
+
+The migration tool:
+- Preserves ticket IDs, timestamps, and all data
+- Skips tickets that already exist in the target
+- Leaves your original `tickets.json` unchanged
+- Shows a summary of migrated/skipped/failed tickets
+
+After migration, start using the new storage:
+```bash
+export SWARM_TICKETS_STORAGE=sqlite  # or supabase
+npx swarm-tickets
+```
+
 ## 🤖 Using with Claude
 
 The package includes a Claude skill that teaches Claude how to:

package/lib/migrate.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+/**
+ * Migration tool for swarm-tickets
+ * Migrates tickets from JSON to SQLite or Supabase
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+async function migrate(targetStorage, options = {}) {
+  const projectRoot = process.cwd();
+  const jsonPath = options.jsonPath || path.join(projectRoot, 'tickets.json');
+
+  console.log('\n🔄 Swarm Tickets Migration Tool\n');
+
+  // Validate target
+  if (!['sqlite', 'supabase'].includes(targetStorage)) {
+    console.error('❌ Invalid target. Use: sqlite or supabase');
+    process.exit(1);
+  }
+
+  // Check JSON source exists
+  if (!fs.existsSync(jsonPath)) {
+    console.error(`❌ Source file not found: ${jsonPath}`);
+    console.error('   Make sure you have a tickets.json file to migrate from.');
+    process.exit(1);
+  }
+
+  // Read source JSON
+  console.log(`📖 Reading from: ${jsonPath}`);
+  let sourceData;
+  try {
+    sourceData = JSON.parse(fs.readFileSync(jsonPath, 'utf8'));
+  } catch (error) {
+    console.error(`❌ Failed to read JSON: ${error.message}`);
+    process.exit(1);
+  }
+
+  const tickets = sourceData.tickets || [];
+  if (tickets.length === 0) {
+    console.log('ℹ️  No tickets to migrate.');
+    return;
+  }
+
+  console.log(`📋 Found ${tickets.length} tickets to migrate\n`);
+
+  // Set up target storage
+  const { createStorageAdapter } = require('./storage');
+
+  // Override config for target
+  const targetConfig = {
+    type: targetStorage,
+    sqlitePath: options.sqlitePath || path.join(projectRoot, 'tickets.db'),
+    supabaseUrl: process.env.SUPABASE_URL,
+    supabaseKey: process.env.SUPABASE_ANON_KEY,
+    supabaseServiceKey: process.env.SUPABASE_SERVICE_ROLE_KEY
+  };
+
+  // Validate Supabase config
+  if (targetStorage === 'supabase') {
+    if (!targetConfig.supabaseUrl || !targetConfig.supabaseKey) {
+      console.error('❌ Supabase migration requires environment variables:');
+      console.error('   SUPABASE_URL=https://your-project.supabase.co');
+      console.error('   SUPABASE_ANON_KEY=your-anon-key');
+      console.error('   SUPABASE_SERVICE_ROLE_KEY=your-service-key (optional, for auto table creation)');
+      process.exit(1);
+    }
+  }
+
+  let targetAdapter;
+  try {
+    console.log(`🎯 Connecting to ${targetStorage}...`);
+    targetAdapter = await createStorageAdapter(targetConfig);
+    console.log(`✅ Connected to ${targetStorage}\n`);
+  } catch (error) {
+    console.error(`❌ Failed to connect to ${targetStorage}: ${error.message}`);
+    if (targetStorage === 'sqlite') {
+      console.error('   Make sure better-sqlite3 is installed: npm install better-sqlite3');
+    } else {
+      console.error('   Make sure @supabase/supabase-js is installed: npm install @supabase/supabase-js');
+      console.error('   And that your environment variables are set correctly.');
+    }
+    process.exit(1);
+  }
+
+  // Migrate tickets
+  let migrated = 0;
+  let skipped = 0;
+  let failed = 0;
+
+  for (const ticket of tickets) {
+    process.stdout.write(`  Migrating ${ticket.id}... `);
+
+    try {
+      // Check if ticket already exists
+      const existing = await targetAdapter.getTicket(ticket.id);
+      if (existing) {
+        console.log('⏭️  already exists, skipping');
+        skipped++;
+        continue;
+      }
+
+      // Create the ticket with original ID and timestamps
+      await targetAdapter.createTicket({
+        id: ticket.id,
+        route: ticket.route || '',
+        f12Errors: ticket.f12Errors || '',
+        serverErrors: ticket.serverErrors || '',
+        description: ticket.description || '',
+        status: ticket.status || 'open',
+        priority: ticket.priority || null,
+        namespace: ticket.namespace || null,
+        relatedTickets: ticket.relatedTickets || [],
+        swarmActions: (ticket.swarmActions || []).map(a => {
+          if (typeof a === 'string') {
+            return { action: a, result: null, timestamp: ticket.createdAt };
+          }
+          return {
+            action: a.action,
+            result: a.result || null,
+            timestamp: a.timestamp || ticket.createdAt
+          };
+        }),
+        comments: (ticket.comments || []).map(c => ({
+          id: c.id,
+          type: c.type || 'human',
+          author: c.author || 'anonymous',
+          content: c.content || '',
+          metadata: c.metadata || {},
+          timestamp: c.timestamp
+        })),
+        createdAt: ticket.createdAt,
+        updatedAt: ticket.updatedAt
+      });
+
+      console.log('✅');
+      migrated++;
+    } catch (error) {
+      console.log(`❌ ${error.message}`);
+      failed++;
+    }
+  }
+
+  // Summary
+  console.log('\n' + '─'.repeat(40));
+  console.log('📊 Migration Summary:');
+  console.log(`   ✅ Migrated: ${migrated}`);
+  console.log(`   ⏭️  Skipped:  ${skipped}`);
+  console.log(`   ❌ Failed:   ${failed}`);
+  console.log('─'.repeat(40));
+
+  if (migrated > 0) {
+    console.log(`\n🎉 Migration complete!`);
+    console.log(`\nTo use ${targetStorage} storage, start the server with:`);
+    if (targetStorage === 'sqlite') {
+      console.log('   export SWARM_TICKETS_STORAGE=sqlite');
+      console.log('   npx swarm-tickets');
+    } else {
+      console.log('   export SWARM_TICKETS_STORAGE=supabase');
+      console.log('   npx swarm-tickets');
+    }
+  }
+
+  console.log(`\n💡 Tip: Your original tickets.json is unchanged.`);
+  console.log(`   You can rename it to tickets.json.backup once migration looks good.`);
+  console.log('');
+}
+
+module.exports = { migrate };

package/lib/storage/json-adapter.js

@@ -104,8 +104,9 @@ class JsonAdapter extends BaseAdapter {
   }
 
   async createTicket(ticketData) {
+    const now = new Date().toISOString();
     const ticket = {
-      id: this.generateTicketId(),
+      id: ticketData.id || this.generateTicketId(),  // Allow custom ID for migration
       route: ticketData.route || '',
       f12Errors: ticketData.f12Errors || '',
       serverErrors: ticketData.serverErrors || '',
@@ -116,8 +117,8 @@ class JsonAdapter extends BaseAdapter {
       swarmActions: ticketData.swarmActions || [],
       comments: ticketData.comments || [],
       namespace: ticketData.namespace || null,
-      createdAt: new Date().toISOString(),
-      updatedAt: new Date().toISOString()
+      createdAt: ticketData.createdAt || now,  // Allow custom timestamps for migration
+      updatedAt: ticketData.updatedAt || now
     };
 
     this.data.tickets.push(ticket);

package/lib/storage/sqlite-adapter.js

@@ -248,8 +248,8 @@ class SqliteAdapter extends BaseAdapter {
   }
 
   async createTicket(ticketData) {
-    const id = this.generateTicketId();
     const now = new Date().toISOString();
+    const id = ticketData.id || this.generateTicketId();  // Allow custom ID for migration
 
     const ticket = {
       id,
@@ -260,8 +260,8 @@ class SqliteAdapter extends BaseAdapter {
       status: ticketData.status || 'open',
       priority: ticketData.priority || null,
       namespace: ticketData.namespace || null,
-      createdAt: now,
-      updatedAt: now
+      createdAt: ticketData.createdAt || now,  // Allow custom timestamps for migration
+      updatedAt: ticketData.updatedAt || now
     };
 
     const transaction = this.db.transaction(() => {

package/lib/storage/supabase-adapter.js

@@ -246,8 +246,8 @@ class SupabaseAdapter extends BaseAdapter {
   }
 
   async createTicket(ticketData) {
-    const id = this.generateTicketId();
     const now = new Date().toISOString();
+    const id = ticketData.id || this.generateTicketId();  // Allow custom ID for migration
 
     const ticket = {
       id,
@@ -258,8 +258,8 @@ class SupabaseAdapter extends BaseAdapter {
       status: ticketData.status || 'open',
       priority: ticketData.priority || null,
       namespace: ticketData.namespace || null,
-      created_at: now,
-      updated_at: now
+      created_at: ticketData.createdAt || now,  // Allow custom timestamps for migration
+      updated_at: ticketData.updatedAt || now
     };
 
     const { error } = await this.client.from('tickets').insert(ticket);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swarm-tickets",
-  "version": "2.0.3",
+  "version": "2.1.0",
   "description": "Lightweight ticket tracking system for AI-powered bug fixing with Claude-flow/Claude Code. Supports JSON, SQLite, and Supabase storage.",
   "main": "ticket-server.js",
   "bin": {

package/ticket-server.js

@@ -10,6 +10,45 @@ const path = require('path');
 const cors = require('cors');
 const { createStorageAdapter, getStorageConfig } = require('./lib/storage');
 
+// Handle CLI commands before starting server
+const args = process.argv.slice(2);
+if (args[0] === 'migrate') {
+  const { migrate } = require('./lib/migrate');
+  const toIndex = args.indexOf('--to');
+  const target = toIndex !== -1 ? args[toIndex + 1] : null;
+
+  if (!target) {
+    console.log('\nUsage: npx swarm-tickets migrate --to <target>\n');
+    console.log('Targets:');
+    console.log('  sqlite    - Migrate to local SQLite database');
+    console.log('  supabase  - Migrate to Supabase (requires env vars)\n');
+    console.log('Examples:');
+    console.log('  npx swarm-tickets migrate --to sqlite');
+    console.log('  npx swarm-tickets migrate --to supabase\n');
+    process.exit(0);
+  }
+
+  migrate(target).then(() => process.exit(0)).catch(err => {
+    console.error('Migration failed:', err);
+    process.exit(1);
+  });
+} else if (args[0] === 'help' || args[0] === '--help' || args[0] === '-h') {
+  console.log('\n🎫 Swarm Tickets - Bug tracking for AI-powered development\n');
+  console.log('Usage: npx swarm-tickets [command]\n');
+  console.log('Commands:');
+  console.log('  (none)              Start the ticket server');
+  console.log('  migrate --to <db>   Migrate tickets from JSON to sqlite/supabase');
+  console.log('  help                Show this help message\n');
+  console.log('Environment Variables:');
+  console.log('  PORT                       Server port (default: 3456)');
+  console.log('  SWARM_TICKETS_STORAGE      Storage type: json, sqlite, supabase');
+  console.log('  SWARM_TICKETS_SQLITE_PATH  SQLite database path');
+  console.log('  SUPABASE_URL               Supabase project URL');
+  console.log('  SUPABASE_ANON_KEY          Supabase anonymous key');
+  console.log('  SUPABASE_SERVICE_ROLE_KEY  Supabase service role key\n');
+  process.exit(0);
+}
+
 const app = express();
 const PORT = process.env.PORT || 3456;