idea-manager 0.5.0 → 0.6.1

package/README.md

@@ -4,6 +4,8 @@
 
 여러 프로젝트를 동시에 진행하는 개발자를 위한 태스크 관리 도구입니다. 아이디어를 서브 프로젝트와 태스크로 조직화하고, 각 태스크별 프롬프트를 정제하여 Claude Code 등 AI 에이전트에게 전달할 수 있습니다. MCP Server를 내장하고 있어 AI 에이전트가 자율적으로 태스크를 가져가 실행할 수 있습니다.
 
+![IM Workspace](docs/screenshot.png)
+
 ## 핵심 워크플로우
 
 ```

package/package.json

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

package/src/app/projects/[id]/page.tsx

@@ -16,6 +16,7 @@ interface IProject {
   description: string;
   project_path: string | null;
   ai_context: string;
+  watch_enabled: boolean;
 }
 
 function WorkspaceInner({ id }: { id: string }) {
@@ -189,9 +190,10 @@ function WorkspaceInner({ id }: { id: string }) {
     }
   };
 
-  const handleTaskDelete = () => {
-    if (!selectedTaskId) return;
-    setConfirmAction({ type: 'delete-task', id: selectedTaskId });
+  const handleTaskDelete = (taskId?: string) => {
+    const id = taskId || selectedTaskId;
+    if (!id) return;
+    setConfirmAction({ type: 'delete-task', id });
   };
 
   const handleConfirmAction = async () => {
@@ -236,6 +238,18 @@ function WorkspaceInner({ id }: { id: string }) {
     }
   };
 
+  const handleToggleWatch = async () => {
+    if (!project) return;
+    const res = await fetch(`/api/projects/${id}`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ watch_enabled: !project.watch_enabled }),
+    });
+    if (res.ok) {
+      setProject(await res.json());
+    }
+  };
+
   // Keyboard shortcuts (use e.code for Korean IME compatibility)
   useEffect(() => {
     const handler = (e: KeyboardEvent) => {
@@ -304,6 +318,18 @@ function WorkspaceInner({ id }: { id: string }) {
           )}
         </div>
         <div className="flex items-center gap-2">
+          <button
+            onClick={handleToggleWatch}
+            className={`px-3 py-1.5 text-xs border rounded-md transition-colors flex items-center gap-1.5 ${
+              project.watch_enabled
+                ? 'bg-success/15 text-success border-success/30 hover:bg-success/25'
+                : 'bg-muted hover:bg-card-hover text-muted-foreground border-border'
+            }`}
+            title={project.watch_enabled ? 'Watch ON — submitted 태스크 자동 실행' : 'Watch OFF'}
+          >
+            <span className={`inline-block w-2 h-2 rounded-full ${project.watch_enabled ? 'bg-success animate-pulse' : 'bg-muted-foreground/40'}`} />
+            Watch
+          </button>
           <button
             onClick={() => setShowAiPolicy(true)}
             className={`px-3 py-1.5 text-xs border rounded-md transition-colors ${
@@ -391,6 +417,7 @@ function WorkspaceInner({ id }: { id: string }) {
             onCreateTask={handleCreateTask}
             onStatusChange={handleTaskStatusChange}
             onTodayToggle={handleTaskTodayToggle}
+            onDeleteTask={handleTaskDelete}
           />
         </div>
 

package/src/cli.ts

@@ -38,6 +38,23 @@ program
     await startMcpServer(ctx);
   });
 
+program
+  .command('watch')
+  .description('Watch for submitted tasks and auto-execute via Claude CLI')
+  .option('--project <id>', 'Watch a specific project (default: all)')
+  .option('--interval <seconds>', 'Polling interval in seconds', '10')
+  .option('--timeout <minutes>', 'Per-task timeout in minutes', '10')
+  .option('--dry-run', 'Show what would be executed without running')
+  .action(async (opts) => {
+    const { startWatcher } = await import('@/lib/watcher');
+    await startWatcher({
+      projectId: opts.project,
+      intervalMs: parseInt(opts.interval) * 1000,
+      timeoutMs: parseInt(opts.timeout) * 60000,
+      dryRun: !!opts.dryRun,
+    });
+  });
+
 program
   .command('start')
   .description('Start the web UI (Next.js dev server on port 3456)')

package/src/components/task/ProjectTree.tsx

@@ -22,6 +22,7 @@ export default function ProjectTree({
   onCreateTask,
   onStatusChange,
   onTodayToggle,
+  onDeleteTask,
 }: {
   subProjects: ISubProjectWithStats[];
   tasks: ITask[];
@@ -34,6 +35,7 @@ export default function ProjectTree({
   onCreateTask: (title: string) => void;
   onStatusChange: (taskId: string, status: TaskStatus) => void;
   onTodayToggle: (taskId: string, isToday: boolean) => void;
+  onDeleteTask: (taskId: string) => void;
 }) {
   const [collapsedSubs, setCollapsedSubs] = useState<Set<string>>(new Set());
   const [addingTaskFor, setAddingTaskFor] = useState<string | null>(null);
@@ -130,7 +132,7 @@ export default function ProjectTree({
                     <div
                       key={task.id}
                       onClick={() => onSelectTask(task.id)}
-                      className={`flex items-center gap-1.5 pl-4 pr-2 py-1.5 cursor-pointer transition-colors text-sm border-l-2 ${
+                      className={`group/task flex items-center gap-1.5 pl-4 pr-2 py-1.5 cursor-pointer transition-colors text-sm border-l-2 ${
                         selectedTaskId === task.id
                           ? 'bg-card-hover border-l-primary'
                           : 'border-l-transparent hover:bg-card-hover/50'
@@ -159,6 +161,17 @@ export default function ProjectTree({
                           *
                         </button>
                       )}
+                      <button
+                        onClick={(e) => {
+                          e.stopPropagation();
+                          onDeleteTask(task.id);
+                        }}
+                        className="flex-shrink-0 text-muted-foreground/0 group-hover/task:text-muted-foreground
+                                   hover:!text-destructive transition-colors text-xs px-0.5"
+                        title="Delete task"
+                      >
+                        ×
+                      </button>
                     </div>
                   ))}
 

package/src/components/task/TaskChat.tsx

@@ -1,14 +1,18 @@
 'use client';
 
 import { useState, useEffect, useRef, useCallback } from 'react';
-import type { ITaskConversation } from '@/types';
+import type { ITaskConversation, TaskStatus } from '@/types';
 import ReactMarkdown from 'react-markdown';
 
+const POLL_INTERVAL = 3000; // Poll every 3s when task is testing
+
 export default function TaskChat({
   basePath,
+  taskStatus,
   onApplyToPrompt,
 }: {
   basePath: string;
+  taskStatus?: TaskStatus;
   onApplyToPrompt: (content: string) => void;
 }) {
   const [messages, setMessages] = useState<ITaskConversation[]>([]);
@@ -17,12 +21,26 @@ export default function TaskChat({
   const messagesEndRef = useRef<HTMLDivElement>(null);
   const inputRef = useRef<HTMLTextAreaElement>(null);
 
-  useEffect(() => {
+  const fetchMessages = useCallback(() => {
     fetch(`${basePath}/chat`)
       .then(r => r.json())
-      .then(data => setMessages(Array.isArray(data) ? data : []));
+      .then(data => {
+        if (Array.isArray(data)) setMessages(data);
+      });
   }, [basePath]);
 
+  // Initial load
+  useEffect(() => {
+    fetchMessages();
+  }, [fetchMessages]);
+
+  // Auto-poll when task is testing (watcher is running)
+  useEffect(() => {
+    if (taskStatus !== 'testing') return;
+    const interval = setInterval(fetchMessages, POLL_INTERVAL);
+    return () => clearInterval(interval);
+  }, [taskStatus, fetchMessages]);
+
   useEffect(() => {
     messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' });
   }, [messages]);
@@ -71,6 +89,12 @@ export default function TaskChat({
     <div className="flex flex-col h-full border-t border-border">
       <div className="flex items-center justify-between px-3 py-1.5 border-b border-border">
         <span className="text-xs font-medium text-muted-foreground uppercase tracking-wider">AI Chat</span>
+        {taskStatus === 'testing' && (
+          <span className="flex items-center gap-1.5 text-xs text-warning">
+            <span className="inline-block w-2 h-2 rounded-full bg-warning animate-pulse" />
+            Executing...
+          </span>
+        )}
       </div>
 
       {/* Messages */}

package/src/components/task/TaskDetail.tsx

@@ -28,11 +28,16 @@ export default function TaskDetail({
 
   const basePath = `/api/projects/${projectId}/sub-projects/${subProjectId}/tasks/${task.id}`;
 
+  // Auto-show chat when task is being executed by watcher
+  useEffect(() => {
+    if (task.status === 'testing') setShowChat(true);
+  }, [task.status]);
+
   // Load prompt
   useEffect(() => {
     setTitle(task.title);
     setDescription(task.description);
-    setShowChat(false);
+    setShowChat(task.status === 'testing');
     fetch(`${basePath}/prompt`)
       .then(r => r.json())
       .then(data => setPromptContent(data.content || ''));
@@ -196,6 +201,7 @@ export default function TaskDetail({
         <div className="h-[45%] flex-shrink-0">
           <TaskChat
             basePath={basePath}
+            taskStatus={task.status}
             onApplyToPrompt={handleApplyToPrompt}
           />
         </div>

package/src/components/task/TaskList.tsx

@@ -17,6 +17,7 @@ export default function TaskList({
   onCreate,
   onStatusChange,
   onTodayToggle,
+  onDelete,
 }: {
   tasks: ITask[];
   selectedTaskId: string | null;
@@ -24,6 +25,7 @@ export default function TaskList({
   onCreate: (title: string) => void;
   onStatusChange: (taskId: string, status: TaskStatus) => void;
   onTodayToggle: (taskId: string, isToday: boolean) => void;
+  onDelete: (taskId: string) => void;
 }) {
   const [newTitle, setNewTitle] = useState('');
   const [adding, setAdding] = useState(false);
@@ -48,7 +50,7 @@ export default function TaskList({
           <div
             key={task.id}
             onClick={() => onSelect(task.id)}
-            className={`flex items-center gap-2 px-3 py-2 cursor-pointer transition-colors text-sm border-l-2 ${
+            className={`group flex items-center gap-2 px-3 py-2 cursor-pointer transition-colors text-sm border-l-2 ${
               selectedTaskId === task.id
                 ? 'bg-card-hover border-l-primary'
                 : 'border-l-transparent hover:bg-card-hover/50'
@@ -77,6 +79,17 @@ export default function TaskList({
                 *
               </button>
             )}
+            <button
+              onClick={(e) => {
+                e.stopPropagation();
+                onDelete(task.id);
+              }}
+              className="flex-shrink-0 text-muted-foreground/0 group-hover:text-muted-foreground
+                         hover:!text-destructive transition-colors text-xs px-0.5"
+              title="Delete task"
+            >
+              ×
+            </button>
           </div>
         ))}
       </div>

package/src/lib/ai/client.ts

@@ -8,11 +8,16 @@ const MAX_TURNS = 80;
 export type OnTextChunk = (text: string) => void;
 export type OnRawEvent = (event: Record<string, unknown>) => void;
 
+export interface RunClaudeOptions {
+  cwd?: string;
+  timeoutMs?: number;
+}
+
 /**
  * Spawn Claude Code CLI and collect the result text.
  * Optional onText callback receives streaming text chunks as they arrive.
  */
-export function runClaude(prompt: string, onText?: OnTextChunk, onRawEvent?: OnRawEvent): Promise<string> {
+export function runClaude(prompt: string, onText?: OnTextChunk, onRawEvent?: OnRawEvent, options?: RunClaudeOptions): Promise<string> {
   return new Promise((resolve, reject) => {
     const useStreamJson = !!(onText || onRawEvent);
     const args = [
@@ -35,11 +40,21 @@ export function runClaude(prompt: string, onText?: OnTextChunk, onRawEvent?: OnR
     }
 
     const proc = spawn(CLI_PATH, args, {
-      cwd: process.cwd(),
+      cwd: options?.cwd || process.cwd(),
       stdio: ['pipe', 'pipe', 'pipe'],
       env: { ...cleanEnv, FORCE_COLOR: '0' },
     });
 
+    // Timeout handling
+    let timeoutTimer: ReturnType<typeof setTimeout> | null = null;
+    let timedOut = false;
+    if (options?.timeoutMs) {
+      timeoutTimer = setTimeout(() => {
+        timedOut = true;
+        proc.kill('SIGTERM');
+      }, options.timeoutMs);
+    }
+
     // Write prompt to stdin and close it
     proc.stdin?.write(prompt);
     proc.stdin?.end();
@@ -99,10 +114,15 @@ export function runClaude(prompt: string, onText?: OnTextChunk, onRawEvent?: OnR
     });
 
     proc.on('exit', (code, signal) => {
+      if (timeoutTimer) clearTimeout(timeoutTimer);
       // Clean up known CLI noise from text output
       if (!useStreamJson) {
         resultText = resultText.replace(/Error: Reached max turns \(\d+\)\s*/g, '').trim();
       }
+      if (timedOut) {
+        reject(new Error(`Claude CLI timed out after ${Math.round((options?.timeoutMs || 0) / 1000)}s`));
+        return;
+      }
       if (code !== 0 && !resultText) {
         const detail = stderrText.slice(0, 500) || (signal ? `killed by signal ${signal}` : 'no output');
         reject(new Error(`Claude CLI exited with code ${code}: ${detail}`));

package/src/lib/db/queries/projects.ts

@@ -2,14 +2,31 @@ import { getDb } from '../index';
 import { generateId } from '../../utils/id';
 import type { IProject } from '@/types';
 
+interface ProjectRow {
+  id: string;
+  name: string;
+  description: string;
+  project_path: string | null;
+  ai_context: string;
+  watch_enabled: number;
+  created_at: string;
+  updated_at: string;
+}
+
+function rowToProject(row: ProjectRow): IProject {
+  return { ...row, watch_enabled: row.watch_enabled === 1 };
+}
+
 export function listProjects(): IProject[] {
   const db = getDb();
-  return db.prepare('SELECT * FROM projects ORDER BY updated_at DESC').all() as IProject[];
+  const rows = db.prepare('SELECT * FROM projects ORDER BY updated_at DESC').all() as ProjectRow[];
+  return rows.map(rowToProject);
 }
 
 export function getProject(id: string): IProject | undefined {
   const db = getDb();
-  return db.prepare('SELECT * FROM projects WHERE id = ?').get(id) as IProject | undefined;
+  const row = db.prepare('SELECT * FROM projects WHERE id = ?').get(id) as ProjectRow | undefined;
+  return row ? rowToProject(row) : undefined;
 }
 
 export function createProject(name: string, description: string = '', projectPath?: string): IProject {
@@ -30,7 +47,7 @@ export function createProject(name: string, description: string = '', projectPat
   return getProject(id)!;
 }
 
-export function updateProject(id: string, data: { name?: string; description?: string; project_path?: string | null; ai_context?: string }): IProject | undefined {
+export function updateProject(id: string, data: { name?: string; description?: string; project_path?: string | null; ai_context?: string; watch_enabled?: boolean }): IProject | undefined {
   const db = getDb();
   const project = getProject(id);
   if (!project) return undefined;
@@ -38,12 +55,13 @@ export function updateProject(id: string, data: { name?: string; description?: s
   const now = new Date().toISOString();
 
   db.prepare(
-    'UPDATE projects SET name = ?, description = ?, project_path = ?, ai_context = ?, updated_at = ? WHERE id = ?'
+    'UPDATE projects SET name = ?, description = ?, project_path = ?, ai_context = ?, watch_enabled = ?, updated_at = ? WHERE id = ?'
   ).run(
     data.name ?? project.name,
     data.description ?? project.description,
     data.project_path !== undefined ? data.project_path : project.project_path,
     data.ai_context !== undefined ? data.ai_context : (project.ai_context ?? ''),
+    data.watch_enabled !== undefined ? (data.watch_enabled ? 1 : 0) : (project.watch_enabled ? 1 : 0),
     now,
     id,
   );

package/src/lib/db/schema.ts

@@ -30,6 +30,9 @@ export function initSchema(db: Database.Database): void {
   if (!projCols.some(c => c.name === 'ai_context')) {
     db.exec("ALTER TABLE projects ADD COLUMN ai_context TEXT NOT NULL DEFAULT ''");
   }
+  if (!projCols.some(c => c.name === 'watch_enabled')) {
+    db.exec("ALTER TABLE projects ADD COLUMN watch_enabled INTEGER NOT NULL DEFAULT 0");
+  }
 
   // v2 tables
   db.exec(`

package/src/lib/watcher.ts

@@ -0,0 +1,236 @@
+import fs from 'fs';
+import { runClaude } from './ai/client';
+import { listProjects, getProject } from './db/queries/projects';
+import { getSubProject } from './db/queries/sub-projects';
+import { getTasksByProject, getTask, updateTask } from './db/queries/tasks';
+import { getTaskPrompt } from './db/queries/task-prompts';
+import { addTaskConversation } from './db/queries/task-conversations';
+import type { ITask, IProject } from '@/types';
+
+export interface WatcherOptions {
+  projectId?: string;
+  intervalMs: number;
+  timeoutMs: number;
+  dryRun: boolean;
+}
+
+const PROGRESS_SAVE_INTERVAL = 5000; // Save streaming output to DB every 5s
+
+function timestamp(): string {
+  return new Date().toLocaleTimeString('ko-KR', { hour12: false });
+}
+
+function log(msg: string) {
+  console.log(`[IM Watch] ${msg}`);
+}
+
+function logTask(msg: string) {
+  console.log(`  ${msg}`);
+}
+
+function formatDuration(ms: number): string {
+  const s = Math.floor(ms / 1000);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  const rem = s % 60;
+  return `${m}m ${rem}s`;
+}
+
+function resolveCwd(task: ITask, project: IProject): string | null {
+  const subProject = getSubProject(task.sub_project_id);
+  if (subProject?.folder_path && fs.existsSync(subProject.folder_path)) {
+    return subProject.folder_path;
+  }
+  if (project.project_path && fs.existsSync(project.project_path)) {
+    return project.project_path;
+  }
+  return null;
+}
+
+async function executeTask(task: ITask, project: IProject, options: WatcherOptions): Promise<void> {
+  const cwd = resolveCwd(task, project);
+  if (!cwd) {
+    logTask(`⚠ Skip "${task.title}" — no folder_path or project_path set`);
+    return;
+  }
+
+  const prompt = getTaskPrompt(task.id);
+  if (!prompt?.content?.trim()) {
+    logTask(`⚠ Skip "${task.title}" — no prompt content`);
+    return;
+  }
+
+  const fresh = getTask(task.id);
+  if (!fresh || fresh.status !== 'submitted') {
+    logTask(`⚠ Skip "${task.title}" — status already changed`);
+    return;
+  }
+
+  const subProject = getSubProject(task.sub_project_id);
+  const subName = subProject?.name || 'unknown';
+
+  console.log(`[${timestamp()}] ▶ "${task.title}" (sub: ${subName}, cwd: ${cwd})`);
+
+  if (options.dryRun) {
+    logTask(`[DRY RUN] Would execute prompt (${prompt.content.length} chars)`);
+    return;
+  }
+
+  // Transition: submitted → testing
+  updateTask(task.id, { status: 'testing' });
+  logTask(`submitted → testing`);
+  addTaskConversation(task.id, 'user', `[watch] 실행 시작`);
+
+  const startTime = Date.now();
+
+  let fullPrompt = prompt.content;
+  if (project.ai_context) {
+    fullPrompt = `Project AI Policy:\n${project.ai_context}\n\n---\n\n${fullPrompt}`;
+  }
+
+  logTask('────────────────────────────────');
+
+  // Accumulate streaming output and periodically save to DB
+  let accumulated = '';
+  let progressMsgId: string | null = null;
+  let lastSaveTime = Date.now();
+
+  const saveProgress = () => {
+    if (!accumulated.trim()) return;
+    const content = `[진행 중]\n${accumulated}`;
+    if (progressMsgId) {
+      // Update existing progress message
+      const { getDb } = require('./db/index');
+      const db = getDb();
+      db.prepare('UPDATE task_conversations SET content = ? WHERE id = ?').run(content, progressMsgId);
+    } else {
+      const msg = addTaskConversation(task.id, 'assistant', content);
+      progressMsgId = msg.id;
+    }
+  };
+
+  try {
+    const onText = (chunk: string) => {
+      process.stdout.write(chunk);
+      accumulated += chunk;
+
+      // Save to DB periodically
+      if (Date.now() - lastSaveTime > PROGRESS_SAVE_INTERVAL) {
+        saveProgress();
+        lastSaveTime = Date.now();
+      }
+    };
+
+    const result = await runClaude(fullPrompt, onText, undefined, {
+      cwd,
+      timeoutMs: options.timeoutMs,
+    });
+
+    process.stdout.write('\n');
+    logTask('────────────────────────────────');
+
+    const duration = Date.now() - startTime;
+    updateTask(task.id, { status: 'done' });
+
+    // Replace progress message with final result
+    if (progressMsgId) {
+      const { getDb } = require('./db/index');
+      const db = getDb();
+      db.prepare('UPDATE task_conversations SET content = ? WHERE id = ?').run(result || '(no output)', progressMsgId);
+    } else {
+      addTaskConversation(task.id, 'assistant', result || '(no output)');
+    }
+
+    console.log(`[${timestamp()}]   ✓ Done (${formatDuration(duration)})`);
+  } catch (err) {
+    const duration = Date.now() - startTime;
+    process.stdout.write('\n');
+    logTask('────────────────────────────────');
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    updateTask(task.id, { status: 'problem' });
+
+    // Replace progress message with error
+    if (progressMsgId) {
+      const { getDb } = require('./db/index');
+      const db = getDb();
+      db.prepare('UPDATE task_conversations SET content = ? WHERE id = ?').run(`[error] ${errorMsg}`, progressMsgId);
+    } else {
+      addTaskConversation(task.id, 'assistant', `[error] ${errorMsg}`);
+    }
+
+    console.log(`[${timestamp()}]   ✗ Failed (${formatDuration(duration)}): ${errorMsg}`);
+  }
+}
+
+export async function startWatcher(options: WatcherOptions): Promise<void> {
+  if (options.projectId) {
+    const project = getProject(options.projectId);
+    if (!project) {
+      console.error(`Error: Project "${options.projectId}" not found.`);
+      process.exit(1);
+    }
+    log(`Watching project: "${project.name}" (${project.id})`);
+  } else {
+    log(`Watching all watch-enabled projects`);
+  }
+
+  log(`Polling every ${options.intervalMs / 1000}s | Timeout: ${options.timeoutMs / 60000}m${options.dryRun ? ' | DRY RUN' : ''}`);
+  log('─'.repeat(50));
+  log('Press Ctrl+C to stop\n');
+
+  let isProcessing = false;
+  let shuttingDown = false;
+
+  const poll = async () => {
+    if (isProcessing || shuttingDown) return;
+    isProcessing = true;
+
+    try {
+      // Only process watch-enabled projects
+      const projects = options.projectId
+        ? [getProject(options.projectId)!].filter(p => p)
+        : listProjects().filter(p => p.watch_enabled);
+
+      const submittedTasks: { task: ITask; project: IProject }[] = [];
+
+      for (const project of projects) {
+        const tasks = getTasksByProject(project.id).filter(t => t.status === 'submitted');
+        for (const task of tasks) {
+          submittedTasks.push({ task, project });
+        }
+      }
+
+      if (submittedTasks.length > 0) {
+        console.log(`[${timestamp()}] Found ${submittedTasks.length} submitted task(s)`);
+        for (const { task, project } of submittedTasks) {
+          if (shuttingDown) break;
+          await executeTask(task, project, options);
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`[${timestamp()}] Poll error: ${msg}`);
+    } finally {
+      isProcessing = false;
+    }
+  };
+
+  const shutdown = () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    console.log(`\n[IM Watch] Shutting down...${isProcessing ? ' (waiting for current task)' : ''}`);
+    if (!isProcessing) process.exit(0);
+    const checkDone = setInterval(() => {
+      if (!isProcessing) {
+        clearInterval(checkDone);
+        process.exit(0);
+      }
+    }, 500);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  await poll();
+  setInterval(poll, options.intervalMs);
+}

package/src/types/index.ts

@@ -4,6 +4,7 @@ export interface IProject {
   description: string;
   project_path: string | null;
   ai_context: string;
+  watch_enabled: boolean;
   created_at: string;
   updated_at: string;
 }