@codexa/cli 9.0.35 → 9.0.36

package/commands/migrate.ts

@@ -0,0 +1,137 @@
+import { createClient, type Client } from "@libsql/client";
+import { initSchema } from "../db/schema";
+import { getDb } from "../db/connection";
+import { existsSync } from "fs";
+import { join } from "path";
+
+const TABLES_IN_ORDER = [
+  "specs",
+  "project",
+  "standards",
+  "product_context",
+  "lib_contexts",
+  "agent_lib_mappings",
+  "implementation_patterns",
+  "architectural_analyses",
+  "project_utilities",
+  "schema_migrations",
+  "context",
+  "tasks",
+  "decisions",
+  "artifacts",
+  "review",
+  "snapshots",
+  "knowledge",
+  "gate_bypasses",
+  "product_goals",
+  "product_features",
+  "knowledge_graph",
+  "reasoning_log",
+  "agent_performance",
+  "knowledge_acknowledgments",
+];
+
+interface MigrateOptions {
+  dbPath?: string;
+  dryRun?: boolean;
+}
+
+export async function migrateToTurso(options: MigrateOptions = {}): Promise<void> {
+  const localPath = options.dbPath || join(process.cwd(), ".codexa", "db", "workflow.db");
+
+  if (!existsSync(localPath)) {
+    console.error(`\nArquivo nao encontrado: ${localPath}`);
+    console.error("Use --db-path para especificar o caminho do workflow.db\n");
+    return;
+  }
+
+  console.log(`\n${"═".repeat(50)}`);
+  console.log("MIGRACAO: SQLite local → Turso");
+  console.log(`${"═".repeat(50)}\n`);
+  console.log(`Origem:  ${localPath}`);
+
+  // 1. Abrir DB local via @libsql/client file: mode
+  const localClient = createClient({ url: `file:${localPath}` });
+
+  // 2. Garantir que o schema remoto esta atualizado
+  console.log("Destino: inicializando schema no Turso...");
+  await initSchema();
+  const remoteClient = getDb();
+
+  const remoteUrl = process.env.CODEXA_DB_URL || "(config.json)";
+  console.log(`Destino: ${remoteUrl}\n`);
+
+  if (options.dryRun) {
+    console.log("[DRY RUN] Nenhum dado sera escrito.\n");
+  }
+
+  // 3. Para cada tabela, ler colunas do schema remoto
+  let totalRows = 0;
+  let totalTables = 0;
+
+  for (const table of TABLES_IN_ORDER) {
+    // Verificar se a tabela existe no local
+    const localTableCheck = await localClient.execute({
+      sql: "SELECT name FROM sqlite_master WHERE type='table' AND name=?",
+      args: [table],
+    });
+    if (localTableCheck.rows.length === 0) continue;
+
+    // Pegar colunas do schema remoto (as que importam)
+    const remoteColumns = await remoteClient.execute(`PRAGMA table_info(${table})`);
+    const columnNames = remoteColumns.rows.map((r: any) => r.name as string);
+
+    if (columnNames.length === 0) continue;
+
+    // Pegar colunas do local para saber quais existem nos dois
+    const localColumns = await localClient.execute(`PRAGMA table_info(${table})`);
+    const localColumnNames = new Set(localColumns.rows.map((r: any) => r.name as string));
+
+    // Usar apenas colunas que existem em ambos
+    const commonColumns = columnNames.filter((c) => localColumnNames.has(c));
+    if (commonColumns.length === 0) continue;
+
+    // Ler dados do local (apenas colunas comuns)
+    const selectSql = `SELECT ${commonColumns.map((c) => `"${c}"`).join(", ")} FROM "${table}"`;
+    const localData = await localClient.execute(selectSql);
+
+    if (localData.rows.length === 0) continue;
+
+    const count = localData.rows.length;
+    totalRows += count;
+    totalTables++;
+
+    if (options.dryRun) {
+      console.log(`  ${table}: ${count} registros`);
+      continue;
+    }
+
+    // Inserir no remoto em batches (max 20 statements por batch)
+    const placeholders = commonColumns.map(() => "?").join(", ");
+    const insertSql = `INSERT OR IGNORE INTO "${table}" (${commonColumns.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders})`;
+
+    const BATCH_SIZE = 20;
+    for (let i = 0; i < localData.rows.length; i += BATCH_SIZE) {
+      const batch = localData.rows.slice(i, i + BATCH_SIZE);
+      await remoteClient.batch(
+        batch.map((row: any) => ({
+          sql: insertSql,
+          args: commonColumns.map((col) => row[col] ?? null),
+        })),
+        "write"
+      );
+    }
+
+    console.log(`  ${table}: ${count} registros migrados`);
+  }
+
+  localClient.close();
+
+  console.log(`\n${"─".repeat(50)}`);
+  if (options.dryRun) {
+    console.log(`[DRY RUN] ${totalRows} registros em ${totalTables} tabelas seriam migrados.`);
+  } else {
+    console.log(`Migracao concluida: ${totalRows} registros em ${totalTables} tabelas.`);
+  }
+  console.log();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codexa/cli",
-  "version": "9.0.35",
+  "version": "9.0.36",
   "description": "Orchestrated workflow system for Claude Code - manages feature development through parallel subagents with structured phases, gates, and quality enforcement.",
   "type": "module",
   "bin": {

package/workflow.ts

@@ -41,6 +41,7 @@ import {
   architectCancel,
 } from "./commands/architect";
 import { teamSuggest } from "./commands/team";
+import { migrateToTurso } from "./commands/migrate";
 import { initSchema } from "./db/schema";
 import { closeDb, dbGet, dbRun, ensureDatabase, getResolvedDbUrl } from "./db/connection";
 import { execSync } from "child_process";
@@ -574,6 +575,15 @@ program
     console.log(`\nBanco de dados inicializado: ${url}\n`);
   });
 
+program
+  .command("migrate")
+  .description("Migra dados do SQLite local (.codexa/db/workflow.db) para o Turso")
+  .option("--db-path <path>", "Caminho do workflow.db local (padrao: .codexa/db/workflow.db)")
+  .option("--dry-run", "Simula a migracao sem escrever dados")
+  .action(async (options) => {
+    await migrateToTurso({ dbPath: options.dbPath, dryRun: options.dryRun });
+  });
+
 // ═══════════════════════════════════════════════════════════════
 // DISCOVER
 // ═══════════════════════════════════════════════════════════════