idea-manager 0.8.4 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "idea-manager",
-  "version": "0.8.4",
+  "version": "0.9.0",
   "description": "AI 기반 브레인스토밍 → 구조화 → 프롬프트 생성 도구. MCP Server 내장.",
   "keywords": [
     "brainstorm",

package/src/cli.ts

@@ -96,4 +96,38 @@ program
     process.on('SIGTERM', () => { child.kill(); process.exit(0); });
   });
 
+const syncCmd = program
+  .command('sync')
+  .description('Sync data via GitHub repository')
+  .action(async () => {
+    const { syncStatus } = await import('./lib/sync');
+    await syncStatus();
+  });
+
+syncCmd
+  .command('init')
+  .description('Initialize sync with a GitHub repository')
+  .action(async () => {
+    const { syncInit } = await import('./lib/sync');
+    await syncInit();
+  });
+
+syncCmd
+  .command('push')
+  .description('Export data and push to GitHub')
+  .option('-m, --message <msg>', 'Custom commit message')
+  .action(async (opts) => {
+    const { syncPush } = await import('./lib/sync');
+    await syncPush(opts.message);
+  });
+
+syncCmd
+  .command('pull')
+  .description('Pull from GitHub and import data')
+  .option('--no-backup', 'Skip database backup before import')
+  .action(async (opts) => {
+    const { syncPull } = await import('./lib/sync');
+    await syncPull({ backup: opts.backup });
+  });
+
 program.parse();

package/src/lib/sync/exporter.ts

@@ -0,0 +1,37 @@
+import fs from 'fs';
+import { getDb } from '../db';
+
+// v2 active tables
+const V2_TABLES = ['projects', 'brainstorms', 'sub_projects', 'tasks', 'task_prompts', 'task_conversations'];
+
+function getExistingTables(db: ReturnType<typeof getDb>): string[] {
+  const rows = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'").all() as { name: string }[];
+  return rows.map(r => r.name);
+}
+
+export function exportToFile(filePath: string): { tables: Record<string, number> } {
+  const db = getDb();
+  const existingTables = getExistingTables(db);
+
+  const tables: Record<string, unknown[]> = {};
+  const counts: Record<string, number> = {};
+
+  // Export all known tables using raw SELECT for perfect round-trip
+  for (const table of V2_TABLES) {
+    if (existingTables.includes(table)) {
+      const rows = db.prepare(`SELECT * FROM ${table}`).all();
+      tables[table] = rows;
+      counts[table] = rows.length;
+    }
+  }
+
+  const data = {
+    version: 2,
+    exportedAt: new Date().toISOString(),
+    tables,
+  };
+
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
+
+  return { tables: counts };
+}

package/src/lib/sync/git.ts

@@ -0,0 +1,113 @@
+import { execFile } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+function quoteArg(arg: string): string {
+  // Quote args with spaces for shell mode
+  if (arg.includes(' ') || arg.includes('"')) {
+    return `"${arg.replace(/"/g, '\\"')}"`;
+  }
+  return arg;
+}
+
+function exec(cmd: string, args: string[], cwd?: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const quotedArgs = args.map(quoteArg);
+    execFile(cmd, quotedArgs, { cwd, shell: true, timeout: 60000 }, (err, stdout, stderr) => {
+      if (err) {
+        reject(new Error(stderr?.trim() || err.message));
+      } else {
+        resolve(stdout.trim());
+      }
+    });
+  });
+}
+
+export async function isGitInstalled(): Promise<boolean> {
+  try { await exec('git', ['--version']); return true; } catch { return false; }
+}
+
+export async function isGhInstalled(): Promise<boolean> {
+  try { await exec('gh', ['--version']); return true; } catch { return false; }
+}
+
+export async function isGhAuthenticated(): Promise<boolean> {
+  try { await exec('gh', ['auth', 'status']); return true; } catch { return false; }
+}
+
+export function isGitRepo(dir: string): boolean {
+  return fs.existsSync(path.join(dir, '.git'));
+}
+
+export async function ghCreateRepo(name: string): Promise<string> {
+  // Create private repo and get URL
+  const result = await exec('gh', ['repo', 'create', name, '--private', '--confirm']);
+  // Extract repo URL from output
+  const urlMatch = result.match(/https:\/\/github\.com\/\S+/);
+  if (urlMatch) return urlMatch[0];
+  // Fallback: query the repo URL
+  const url = await exec('gh', ['repo', 'view', name, '--json', 'url', '-q', '.url']);
+  return url;
+}
+
+export async function gitClone(url: string, targetDir: string): Promise<void> {
+  await exec('git', ['clone', url, targetDir]);
+}
+
+export async function gitInit(cwd: string): Promise<void> {
+  await exec('git', ['init'], cwd);
+  // Set default branch to main
+  await exec('git', ['branch', '-M', 'main'], cwd);
+}
+
+export async function gitAddRemote(cwd: string, url: string): Promise<void> {
+  await exec('git', ['remote', 'add', 'origin', url], cwd);
+}
+
+export async function gitAdd(cwd: string, files: string[]): Promise<void> {
+  await exec('git', ['add', ...files], cwd);
+}
+
+export async function gitCommit(cwd: string, message: string): Promise<void> {
+  await exec('git', ['commit', '-m', message], cwd);
+}
+
+export async function gitPush(cwd: string, setUpstream = false): Promise<void> {
+  if (setUpstream) {
+    // Ensure branch is named main, then push
+    try { await exec('git', ['branch', '-M', 'main'], cwd); } catch { /* already main */ }
+    await exec('git', ['push', '-u', 'origin', 'main'], cwd);
+  } else {
+    await exec('git', ['push'], cwd);
+  }
+}
+
+export async function gitPull(cwd: string): Promise<void> {
+  await exec('git', ['pull'], cwd);
+}
+
+export async function hasRemote(cwd: string): Promise<boolean> {
+  try {
+    const result = await exec('git', ['remote'], cwd);
+    return result.includes('origin');
+  } catch { return false; }
+}
+
+export async function hasCommits(cwd: string): Promise<boolean> {
+  try {
+    await exec('git', ['rev-parse', 'HEAD'], cwd);
+    return true;
+  } catch { return false; }
+}
+
+export async function getRemoteUrl(cwd: string): Promise<string | null> {
+  try {
+    return await exec('git', ['remote', 'get-url', 'origin'], cwd);
+  } catch { return null; }
+}
+
+export async function getLastCommitInfo(cwd: string): Promise<string | null> {
+  try {
+    return await exec('git', ['log', '-1', '--format=%ci %s'], cwd);
+  } catch { return null; }
+}

package/src/lib/sync/importer.ts

@@ -0,0 +1,69 @@
+import fs from 'fs';
+import { getDb } from '../db';
+import { getDbPath } from '../utils/paths';
+
+// Import order: parents first, then children
+const IMPORT_ORDER = ['projects', 'brainstorms', 'sub_projects', 'tasks', 'task_prompts', 'task_conversations'];
+// Delete order: children first, then parents
+const DELETE_ORDER = [...IMPORT_ORDER].reverse();
+
+export function backupDb(): string {
+  const dbPath = getDbPath();
+  const db = getDb();
+  // Flush WAL before backup
+  db.pragma('wal_checkpoint(TRUNCATE)');
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const backupPath = `${dbPath}.backup-${timestamp}`;
+  fs.copyFileSync(dbPath, backupPath);
+  return backupPath;
+}
+
+export function importFromFile(filePath: string): { tables: Record<string, number> } {
+  const raw = fs.readFileSync(filePath, 'utf-8');
+  const data = JSON.parse(raw);
+
+  if (!data.version || !data.tables) {
+    throw new Error('Invalid sync data format');
+  }
+
+  const db = getDb();
+  const counts: Record<string, number> = {};
+
+  const doImport = db.transaction(() => {
+    db.pragma('foreign_keys = OFF');
+
+    // Delete all data in reverse dependency order
+    for (const table of DELETE_ORDER) {
+      try {
+        db.prepare(`DELETE FROM ${table}`).run();
+      } catch {
+        // Table might not exist, skip
+      }
+    }
+
+    // Insert data in dependency order
+    for (const table of IMPORT_ORDER) {
+      const rows = data.tables[table];
+      if (!rows || !Array.isArray(rows) || rows.length === 0) {
+        counts[table] = 0;
+        continue;
+      }
+
+      const columns = Object.keys(rows[0]);
+      const placeholders = columns.map(() => '?').join(', ');
+      const stmt = db.prepare(`INSERT INTO ${table} (${columns.join(', ')}) VALUES (${placeholders})`);
+
+      for (const row of rows) {
+        stmt.run(...columns.map(col => row[col] ?? null));
+      }
+
+      counts[table] = rows.length;
+    }
+
+    db.pragma('foreign_keys = ON');
+  });
+
+  doImport();
+
+  return { tables: counts };
+}

package/src/lib/sync/index.ts

@@ -0,0 +1,211 @@
+import readline from 'readline';
+import path from 'path';
+import fs from 'fs';
+import { getSyncDir } from '../utils/paths';
+import * as git from './git';
+import { exportToFile } from './exporter';
+import { importFromFile, backupDb } from './importer';
+
+const SYNC_FILE = 'im-data.json';
+
+function ask(question: string, defaultValue?: string): Promise<string> {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => {
+    const prompt = defaultValue ? `${question} [${defaultValue}]: ` : `${question}: `;
+    rl.question(prompt, answer => {
+      rl.close();
+      resolve(answer.trim() || defaultValue || '');
+    });
+  });
+}
+
+function printCounts(label: string, counts: Record<string, number>) {
+  const parts = Object.entries(counts)
+    .filter(([, v]) => v > 0)
+    .map(([k, v]) => `${k}: ${v}`);
+  console.log(`  ${label}: ${parts.join(', ') || 'empty'}`);
+}
+
+export async function syncInit() {
+  const syncDir = getSyncDir();
+
+  if (git.isGitRepo(syncDir)) {
+    const remoteUrl = await git.getRemoteUrl(syncDir);
+    console.log(`\n  Sync already initialized.`);
+    if (remoteUrl) console.log(`  Remote: ${remoteUrl}`);
+    console.log(`  Use "im sync push" or "im sync pull"\n`);
+    return;
+  }
+
+  // Check git
+  if (!await git.isGitInstalled()) {
+    console.error('\n  Error: git is not installed. Please install git first.\n');
+    process.exit(1);
+  }
+
+  let repoUrl = '';
+
+  // Try gh CLI
+  const ghAvailable = await git.isGhInstalled() && await git.isGhAuthenticated();
+
+  if (ghAvailable) {
+    const useGh = await ask('Create a new private GitHub repo? (Y/n)', 'Y');
+
+    if (useGh.toLowerCase() !== 'n') {
+      const repoName = await ask('Repository name', 'idea-manager-sync');
+
+      console.log(`\n  Creating GitHub repo "${repoName}"...`);
+      try {
+        repoUrl = await git.ghCreateRepo(repoName);
+        console.log(`  Created: ${repoUrl}`);
+      } catch (err) {
+        console.error(`  Failed to create repo: ${(err as Error).message}`);
+        console.log('  Falling back to manual URL input.\n');
+      }
+    }
+  }
+
+  if (!repoUrl) {
+    repoUrl = await ask('Enter git repository URL');
+    if (!repoUrl) {
+      console.error('\n  Error: Repository URL is required.\n');
+      process.exit(1);
+    }
+  }
+
+  // Clean sync dir and clone
+  console.log(`\n  Cloning to ${syncDir}...`);
+  try {
+    // Remove sync dir contents (keep the dir itself)
+    const entries = fs.readdirSync(syncDir);
+    for (const e of entries) {
+      fs.rmSync(path.join(syncDir, e), { recursive: true, force: true });
+    }
+
+    await git.gitClone(repoUrl, syncDir);
+  } catch {
+    // Clone into existing empty dir — init + add remote instead
+    try {
+      await git.gitInit(syncDir);
+      await git.gitAddRemote(syncDir, repoUrl);
+    } catch (err2) {
+      console.error(`  Failed: ${(err2 as Error).message}\n`);
+      process.exit(1);
+    }
+  }
+
+  // Create .gitignore
+  fs.writeFileSync(path.join(syncDir, '.gitignore'), '.DS_Store\n', 'utf-8');
+
+  // Initial export + push if repo is empty
+  if (!fs.existsSync(path.join(syncDir, SYNC_FILE))) {
+    console.log('  Performing initial export...');
+    const { tables } = exportToFile(path.join(syncDir, SYNC_FILE));
+    printCounts('Exported', tables);
+
+    try {
+      await git.gitAdd(syncDir, ['.gitignore', SYNC_FILE]);
+      await git.gitCommit(syncDir, 'sync: initial export');
+      await git.gitPush(syncDir, true);
+      console.log('  Pushed initial data.\n');
+    } catch (err) {
+      console.log(`  Committed locally. Push manually if needed: ${(err as Error).message}\n`);
+    }
+  }
+
+  console.log(`  Sync initialized successfully!`);
+  console.log(`  Remote: ${repoUrl}\n`);
+}
+
+export async function syncPush(message?: string) {
+  const syncDir = getSyncDir();
+
+  if (!git.isGitRepo(syncDir)) {
+    console.error('\n  Sync not initialized. Run "im sync init" first.\n');
+    process.exit(1);
+  }
+
+  // Export
+  const filePath = path.join(syncDir, SYNC_FILE);
+  const { tables } = exportToFile(filePath);
+  printCounts('Exported', tables);
+
+  // Commit + push
+  try {
+    await git.gitAdd(syncDir, [SYNC_FILE]);
+    const commitMsg = message || `sync: ${new Date().toISOString().slice(0, 19).replace('T', ' ')}`;
+    await git.gitCommit(syncDir, commitMsg);
+  } catch (err) {
+    const msg = (err as Error).message;
+    if (msg.includes('nothing to commit') || msg.includes('no changes')) {
+      console.log('  Already up to date.\n');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const firstPush = !await git.hasCommits(syncDir).catch(() => true);
+    await git.gitPush(syncDir, firstPush);
+    console.log('  Pushed successfully.\n');
+  } catch (err) {
+    console.error(`  Push failed: ${(err as Error).message}`);
+    console.log('  Data is committed locally. Try pushing manually.\n');
+  }
+}
+
+export async function syncPull(opts: { backup?: boolean } = {}) {
+  const syncDir = getSyncDir();
+
+  if (!git.isGitRepo(syncDir)) {
+    console.error('\n  Sync not initialized. Run "im sync init" first.\n');
+    process.exit(1);
+  }
+
+  // Pull
+  try {
+    await git.gitPull(syncDir);
+    console.log('  Pulled latest data.');
+  } catch (err) {
+    console.error(`  Pull failed: ${(err as Error).message}\n`);
+    process.exit(1);
+  }
+
+  const filePath = path.join(syncDir, SYNC_FILE);
+  if (!fs.existsSync(filePath)) {
+    console.log('  No sync data found. Run "im sync push" on another machine first.\n');
+    return;
+  }
+
+  // Backup
+  if (opts.backup !== false) {
+    const backupPath = backupDb();
+    console.log(`  Backup: ${backupPath}`);
+  }
+
+  // Import
+  const { tables } = importFromFile(filePath);
+  printCounts('Imported', tables);
+  console.log('  Done. Refresh the browser to see updated data.\n');
+}
+
+export async function syncStatus() {
+  const syncDir = getSyncDir();
+
+  if (!git.isGitRepo(syncDir)) {
+    console.log('\n  Sync not initialized.');
+    console.log('  Run "im sync init" to set up.\n');
+    return;
+  }
+
+  const remoteUrl = await git.getRemoteUrl(syncDir);
+  const lastCommit = await git.getLastCommitInfo(syncDir);
+  const filePath = path.join(syncDir, SYNC_FILE);
+  const hasData = fs.existsSync(filePath);
+
+  console.log('\n  IM Sync Status');
+  console.log(`  Remote: ${remoteUrl || 'none'}`);
+  console.log(`  Last sync: ${lastCommit || 'never'}`);
+  console.log(`  Data file: ${hasData ? 'exists' : 'not found'}`);
+  console.log(`\n  Commands: im sync push | im sync pull\n`);
+}

package/src/lib/utils/paths.ts

@@ -14,3 +14,12 @@ export function getDataDir(): string {
 export function getDbPath(): string {
   return path.join(getDataDir(), 'im.db');
 }
+
+const SYNC_DIR = path.join(os.homedir(), '.idea-manager', 'sync');
+
+export function getSyncDir(): string {
+  if (!fs.existsSync(SYNC_DIR)) {
+    fs.mkdirSync(SYNC_DIR, { recursive: true });
+  }
+  return SYNC_DIR;
+}