zyflow 0.6.4

package/server/tasks/cli/commands.ts

@@ -0,0 +1,269 @@
+import {
+  initDb,
+  createTask,
+  getTask,
+  listTasks,
+  updateTask,
+  deleteTask,
+  moveTask,
+  getTasksByStatus,
+  searchTasks,
+  Task,
+  TaskStatus,
+  TaskPriority,
+} from '../index.js';
+
+// ANSI color codes
+const colors = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  bgRed: '\x1b[41m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+  bgBlue: '\x1b[44m',
+};
+
+const priorityColors: Record<TaskPriority, string> = {
+  high: colors.red,
+  medium: colors.yellow,
+  low: colors.green,
+};
+
+const statusLabels: Record<TaskStatus, string> = {
+  todo: '📋 To Do',
+  'in-progress': '🔄 In Progress',
+  review: '👀 Review',
+  done: '✅ Done',
+  archived: '📦 Archived',
+};
+
+function formatTask(task: Task): string {
+  const priority = task.priority as TaskPriority;
+  const status = task.status as TaskStatus;
+  const tags = task.tags ? JSON.parse(task.tags) as string[] : [];
+
+  let output = '';
+  output += `${colors.bold}TASK-${task.id}${colors.reset} `;
+  output += `${priorityColors[priority]}[${priority.toUpperCase()}]${colors.reset} `;
+  output += `${task.title}\n`;
+  output += `  ${colors.dim}Status:${colors.reset} ${statusLabels[status]}\n`;
+
+  if (task.description) {
+    output += `  ${colors.dim}Description:${colors.reset} ${task.description}\n`;
+  }
+
+  if (tags.length > 0) {
+    output += `  ${colors.dim}Tags:${colors.reset} ${tags.map((t) => `${colors.cyan}#${t}${colors.reset}`).join(' ')}\n`;
+  }
+
+  if (task.assignee) {
+    output += `  ${colors.dim}Assignee:${colors.reset} ${task.assignee}\n`;
+  }
+
+  return output;
+}
+
+function formatTable(tasks: Task[]): string {
+  if (tasks.length === 0) {
+    return `${colors.dim}No tasks found.${colors.reset}`;
+  }
+
+  const header = `${colors.bold}${'ID'.padEnd(15)} ${'PRIORITY'.padEnd(10)} ${'STATUS'.padEnd(15)} TITLE${colors.reset}`;
+  const rows = tasks.map((task) => {
+    const priority = task.priority as TaskPriority;
+    const status = task.status as TaskStatus;
+    const idStr = `TASK-${task.id}`;
+    return `${idStr.padEnd(15)} ${priorityColors[priority]}${priority.toUpperCase().padEnd(10)}${colors.reset} ${status.padEnd(15)} ${task.title}`;
+  });
+
+  return [header, '-'.repeat(70), ...rows].join('\n');
+}
+
+function formatKanban(tasksByStatus: Record<TaskStatus, Task[]>): string {
+  const statuses: TaskStatus[] = ['todo', 'in-progress', 'review', 'done'];
+  const columnWidth = 25;
+
+  // Header
+  let output = statuses.map((s) => statusLabels[s].padEnd(columnWidth)).join('│') + '\n';
+  output += statuses.map(() => '─'.repeat(columnWidth)).join('┼') + '\n';
+
+  // Find max tasks in any column
+  const maxTasks = Math.max(...statuses.map((s) => tasksByStatus[s].length));
+
+  for (let i = 0; i < maxTasks; i++) {
+    const row = statuses.map((status) => {
+      const task = tasksByStatus[status][i];
+      if (!task) return ' '.repeat(columnWidth);
+      const priority = task.priority as TaskPriority;
+      const short = String(task.id);
+      const title = task.title.slice(0, 15);
+      return `${priorityColors[priority]}●${colors.reset} ${short} ${title}`.padEnd(columnWidth + 10); // extra for color codes
+    });
+    output += row.join('│') + '\n';
+  }
+
+  return output;
+}
+
+export interface CommandOptions {
+  status?: string;
+  priority?: string;
+  tags?: string;
+  assignee?: string;
+  kanban?: boolean;
+  limit?: number;
+  description?: string;
+}
+
+export function handleListCommand(options: CommandOptions): string {
+  initDb();
+
+  if (options.kanban) {
+    const tasksByStatus = getTasksByStatus();
+    return formatKanban(tasksByStatus);
+  }
+
+  const tasks = listTasks({
+    status: options.status as TaskStatus | undefined,
+    priority: options.priority as TaskPriority | undefined,
+    tags: options.tags ? options.tags.split(',') : undefined,
+    assignee: options.assignee,
+    limit: options.limit,
+  });
+
+  return formatTable(tasks);
+}
+
+export function handleAddCommand(title: string, options: CommandOptions): string {
+  initDb();
+
+  // CLI에서 생성하는 태스크는 현재 프로젝트의 default projectId 사용
+  const task = createTask({
+    projectId: process.cwd().toLowerCase().replace(/\//g, '-').replace(/^-/, '') || 'default',
+    title,
+    description: options.description,
+    priority: options.priority as TaskPriority | undefined,
+    tags: options.tags ? options.tags.split(',') : undefined,
+    assignee: options.assignee,
+  });
+
+  return `${colors.green}✓${colors.reset} Created task ${colors.bold}${task.id}${colors.reset}\n\n${formatTask(task)}`;
+}
+
+export function handleViewCommand(id: string): string {
+  initDb();
+
+  const task = getTask(id);
+  if (!task) {
+    return `${colors.red}✗${colors.reset} Task not found: ${id}`;
+  }
+
+  return formatTask(task);
+}
+
+export function handleEditCommand(id: string, options: CommandOptions): string {
+  initDb();
+
+  const task = updateTask(id, {
+    status: options.status as TaskStatus | undefined,
+    priority: options.priority as TaskPriority | undefined,
+    tags: options.tags ? options.tags.split(',') : undefined,
+    assignee: options.assignee,
+  });
+
+  if (!task) {
+    return `${colors.red}✗${colors.reset} Task not found: ${id}`;
+  }
+
+  return `${colors.green}✓${colors.reset} Updated task ${colors.bold}${task.id}${colors.reset}\n\n${formatTask(task)}`;
+}
+
+export function handleMoveCommand(id: string, status: string): string {
+  initDb();
+
+  const validStatuses: TaskStatus[] = ['todo', 'in-progress', 'review', 'done'];
+  if (!validStatuses.includes(status as TaskStatus)) {
+    return `${colors.red}✗${colors.reset} Invalid status: ${status}. Valid values: ${validStatuses.join(', ')}`;
+  }
+
+  const task = moveTask(id, status as TaskStatus);
+  if (!task) {
+    return `${colors.red}✗${colors.reset} Task not found: ${id}`;
+  }
+
+  return `${colors.green}✓${colors.reset} Moved task ${colors.bold}${task.id}${colors.reset} to ${statusLabels[status as TaskStatus]}`;
+}
+
+export function handleSearchCommand(query: string, options: CommandOptions): string {
+  initDb();
+
+  const tasks = searchTasks(query, {
+    limit: options.limit,
+    status: options.status,
+    priority: options.priority,
+  });
+
+  if (tasks.length === 0) {
+    return `${colors.dim}No tasks found matching "${query}"${colors.reset}`;
+  }
+
+  return `Found ${tasks.length} task(s):\n\n${formatTable(tasks)}`;
+}
+
+export function handleDeleteCommand(id: string, confirm: boolean = false): string {
+  initDb();
+
+  const task = getTask(id);
+  if (!task) {
+    return `${colors.red}✗${colors.reset} Task not found: ${id}`;
+  }
+
+  if (!confirm) {
+    return `${colors.yellow}⚠${colors.reset} To delete task ${colors.bold}${id}${colors.reset} "${task.title}", run with --confirm flag`;
+  }
+
+  deleteTask(id);
+  return `${colors.green}✓${colors.reset} Deleted task ${colors.bold}${id}${colors.reset}`;
+}
+
+export function handleHelpCommand(): string {
+  return `
+${colors.bold}zy tasks${colors.reset} - Task management CLI
+
+${colors.bold}USAGE${colors.reset}
+  zy tasks <command> [options]
+
+${colors.bold}COMMANDS${colors.reset}
+  list              List all tasks
+  add <title>       Create a new task
+  view <id>         View task details
+  edit <id>         Edit a task
+  move <id> <status> Move task to a status
+  search <query>    Search tasks
+  delete <id>       Delete a task
+
+${colors.bold}OPTIONS${colors.reset}
+  --status <status>   Filter by status (todo, in-progress, review, done)
+  --priority <p>      Filter/set priority (low, medium, high)
+  --tags <tags>       Filter/set tags (comma-separated)
+  --assignee <name>   Filter/set assignee
+  --kanban            Show kanban board view
+  --limit <n>         Limit results
+  --description <d>   Set description (for add)
+  --confirm           Confirm deletion
+
+${colors.bold}EXAMPLES${colors.reset}
+  zy tasks list --kanban
+  zy tasks add "Fix login bug" --priority high --tags bug,auth
+  zy tasks move TASK-ABC123 in-progress
+  zy tasks search "modal"
+`;
+}

package/server/tasks/cli/index.ts

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+import {
+  handleListCommand,
+  handleAddCommand,
+  handleViewCommand,
+  handleEditCommand,
+  handleMoveCommand,
+  handleSearchCommand,
+  handleDeleteCommand,
+  handleHelpCommand,
+  CommandOptions,
+} from './commands.js';
+
+function parseArgs(args: string[]): { command: string; positional: string[]; options: CommandOptions & { confirm?: boolean } } {
+  const command = args[0] || 'help';
+  const positional: string[] = [];
+  const options: CommandOptions & { confirm?: boolean } = {};
+
+  let i = 1;
+  while (i < args.length) {
+    const arg = args[i];
+
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2);
+
+      if (key === 'kanban' || key === 'confirm') {
+        (options as Record<string, unknown>)[key] = true;
+      } else if (i + 1 < args.length && !args[i + 1].startsWith('--')) {
+        const value = args[i + 1];
+        if (key === 'limit') {
+          options.limit = parseInt(value, 10);
+        } else {
+          (options as Record<string, unknown>)[key] = value;
+        }
+        i++;
+      }
+    } else if (arg.startsWith('-')) {
+      const key = arg.slice(1);
+      const shortMap: Record<string, string> = {
+        p: 'priority',
+        s: 'status',
+        t: 'tags',
+        a: 'assignee',
+        d: 'description',
+        k: 'kanban',
+        l: 'limit',
+      };
+
+      const fullKey = shortMap[key] || key;
+
+      if (fullKey === 'kanban') {
+        options.kanban = true;
+      } else if (i + 1 < args.length && !args[i + 1].startsWith('-')) {
+        const value = args[i + 1];
+        if (fullKey === 'limit') {
+          options.limit = parseInt(value, 10);
+        } else {
+          (options as Record<string, unknown>)[fullKey] = value;
+        }
+        i++;
+      }
+    } else {
+      positional.push(arg);
+    }
+
+    i++;
+  }
+
+  return { command, positional, options };
+}
+
+function main(): void {
+  const args = process.argv.slice(2);
+  const { command, positional, options } = parseArgs(args);
+
+  let output: string;
+
+  try {
+    switch (command) {
+      case 'list':
+      case 'ls':
+        output = handleListCommand(options);
+        break;
+
+      case 'add':
+      case 'create':
+        if (positional.length === 0) {
+          output = 'Error: Title is required. Usage: zy tasks add "Task title"';
+        } else {
+          output = handleAddCommand(positional.join(' '), options);
+        }
+        break;
+
+      case 'view':
+      case 'show':
+        if (positional.length === 0) {
+          output = 'Error: Task ID is required. Usage: zy tasks view TASK-XXX';
+        } else {
+          output = handleViewCommand(positional[0]);
+        }
+        break;
+
+      case 'edit':
+      case 'update':
+        if (positional.length === 0) {
+          output = 'Error: Task ID is required. Usage: zy tasks edit TASK-XXX --status done';
+        } else {
+          output = handleEditCommand(positional[0], options);
+        }
+        break;
+
+      case 'move':
+        if (positional.length < 2) {
+          output = 'Error: Task ID and status required. Usage: zy tasks move TASK-XXX in-progress';
+        } else {
+          output = handleMoveCommand(positional[0], positional[1]);
+        }
+        break;
+
+      case 'search':
+      case 'find':
+        if (positional.length === 0) {
+          output = 'Error: Search query is required. Usage: zy tasks search "keyword"';
+        } else {
+          output = handleSearchCommand(positional.join(' '), options);
+        }
+        break;
+
+      case 'delete':
+      case 'rm':
+        if (positional.length === 0) {
+          output = 'Error: Task ID is required. Usage: zy tasks delete TASK-XXX --confirm';
+        } else {
+          output = handleDeleteCommand(positional[0], options.confirm || false);
+        }
+        break;
+
+      case 'help':
+      case '--help':
+      case '-h':
+      default:
+        output = handleHelpCommand();
+        break;
+    }
+  } catch (error) {
+    output = `Error: ${error instanceof Error ? error.message : String(error)}`;
+  }
+
+  console.log(output);
+}
+
+main();

package/server/tasks/core/search.ts

@@ -0,0 +1,81 @@
+import { getSqlite, getDb } from '../db/client.js'
+import { tasks, Task } from '../db/schema.js'
+import { inArray, eq, and, ne } from 'drizzle-orm'
+
+export interface SearchResult {
+  id: string
+  title: string
+  description: string | null
+  snippet: string
+  rank: number
+}
+
+export interface SearchOptions {
+  limit?: number
+  status?: string
+  priority?: string
+  projectId?: string // 프로젝트별 필터링
+  includeArchived?: boolean // archived 포함 여부
+}
+
+export function searchTasks(query: string, options: SearchOptions = {}): Task[] {
+  const sqlite = getSqlite()
+  const db = getDb()
+  const limit = options.limit || 20
+
+  // Use FTS5 to search
+  // Quote the query to handle special characters
+  const ftsQuery = query
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((term) => `"${term}"*`)
+    .join(' OR ')
+
+  if (!ftsQuery) {
+    return []
+  }
+
+  const stmt = sqlite.prepare(`
+    SELECT tasks.id, bm25(tasks_fts) as rank
+    FROM tasks_fts
+    JOIN tasks ON tasks.id = tasks_fts.id
+    WHERE tasks_fts MATCH ?
+    ORDER BY rank
+    LIMIT ?
+  `)
+
+  const searchResults = stmt.all(ftsQuery, limit) as Array<{ id: number; rank: number }>
+
+  if (searchResults.length === 0) {
+    return []
+  }
+
+  // Fetch full task data with IN clause (fix N+1 query)
+  const taskIds = searchResults.map((r) => r.id)
+
+  // Build filter conditions
+  const conditions = [inArray(tasks.id, taskIds)]
+  if (options.projectId) conditions.push(eq(tasks.projectId, options.projectId))
+  if (options.status) conditions.push(eq(tasks.status, options.status as Task['status']))
+  if (options.priority) conditions.push(eq(tasks.priority, options.priority as Task['priority']))
+  if (!options.includeArchived) conditions.push(ne(tasks.status, 'archived'))
+
+  const fullTasks = db
+    .select()
+    .from(tasks)
+    .where(and(...conditions))
+    .all()
+
+  // Maintain original search ranking order
+  const taskMap = new Map(fullTasks.map((t) => [t.id, t]))
+  return taskIds.map((id) => taskMap.get(id)).filter((t): t is Task => !!t)
+}
+
+export function rebuildSearchIndex(): void {
+  const sqlite = getSqlite()
+
+  // Rebuild the FTS index from scratch
+  sqlite.exec(`
+    INSERT INTO tasks_fts(tasks_fts) VALUES('rebuild');
+  `)
+}