ideaco 1.1.5

package/src/app/api/browse-dir/route.js

@@ -0,0 +1,44 @@
+import { NextResponse } from 'next/server';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { getApiT } from '@/lib/api-i18n';
+
+/**
+ * GET /api/browse-dir?path=xxx - List subdirectories at the given path
+ * Without a path param, returns subdirectories in the user's home directory
+ */
+export async function GET(request) {
+  const t = getApiT(request);
+  try {
+    const { searchParams } = new URL(request.url);
+    const dirPath = searchParams.get('path') || os.homedir();
+
+    // Safety check: ensure path exists and is a directory
+    const resolved = path.resolve(dirPath);
+    if (!fs.existsSync(resolved)) {
+      return NextResponse.json({ error: t('api.pathNotExist') }, { status: 400 });
+    }
+    const stat = fs.statSync(resolved);
+    if (!stat.isDirectory()) {
+      return NextResponse.json({ error: t('api.pathNotDirectory') }, { status: 400 });
+    }
+
+    const entries = fs.readdirSync(resolved, { withFileTypes: true });
+    const dirs = entries
+      .filter(e => e.isDirectory() && !e.name.startsWith('.'))
+      .map(e => ({
+        name: e.name,
+        path: path.join(resolved, e.name),
+      }))
+      .sort((a, b) => a.name.localeCompare(b.name));
+
+    return NextResponse.json({
+      current: resolved,
+      parent: path.dirname(resolved) !== resolved ? path.dirname(resolved) : null,
+      dirs,
+    });
+  } catch (e) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

package/src/app/api/chat/route.js

@@ -0,0 +1,265 @@
+import { NextResponse } from 'next/server';
+import { getCompany } from '@/lib/store';
+import { chatStore } from '@/core/agent/chat-store.js';
+import { getApiT } from '@/lib/api-i18n';
+
+// Store running task states
+const runningTasks = new Map();
+
+export async function POST(request) {
+  const t = getApiT(request);
+  const company = getCompany();
+  if (!company) {
+    return NextResponse.json({ error: t('api.noCompany') }, { status: 400 });
+  }
+  try {
+    const { message } = await request.json();
+    if (!message) {
+      return NextResponse.json({ error: t('api.messageRequired') }, { status: 400 });
+    }
+    const reply = await company.chatWithSecretary(message);
+
+    // If secretary returned a create_department action, auto-trigger department creation flow
+    if (reply.action?.type === 'create_department') {
+      const taskId = `dept_${Date.now()}`;
+      const { departmentName, mission, members } = reply.action;
+      const deptName = departmentName || 'New Project Dept';
+      const deptMission = mission || message;
+
+      runningTasks.set(taskId, { status: 'running', type: 'create_department', startedAt: Date.now() });
+
+      // Async department creation (non-blocking response)
+      (async () => {
+        try {
+          // Secretary already designed the team — create department directly
+          const dept = await company.createDepartmentDirect({
+            departmentName: deptName,
+            mission: deptMission,
+            members: members || [],
+          });
+          console.log(`✅ Department created: ${dept.name}, ${dept.agents.size} people ready`);
+
+          runningTasks.set(taskId, {
+            status: 'completed',
+            summary: {
+              departmentId: dept.id,
+              departmentName: dept.name,
+              memberCount: dept.agents.size,
+              members: dept.getMembers().map(a => ({ name: a.name, role: a.role })),
+            },
+            completedAt: Date.now(),
+          });
+
+          // Append a secretary message to notify the boss
+          const notifyMsg = {
+            role: 'secretary',
+            content: `🎉 "${dept.name}" department has been created! Recruited ${dept.agents.size} employees:\n${dept.getMembers().map(a => `  • ${a.name} (${a.role})`).join('\n')}\n\nTeam is ready, awaiting tasks!`,
+            action: { type: 'department_created', departmentId: dept.id, departmentName: dept.name },
+            time: new Date(),
+          };
+          company.chatHistory.push(notifyMsg);
+          chatStore.appendMessage(company.chatSessionId, notifyMsg);
+          company.save();
+
+          setTimeout(() => runningTasks.delete(taskId), 30 * 60 * 1000);
+        } catch (err) {
+          console.error(`❌ Department creation failed:`, err.message);
+          runningTasks.set(taskId, { status: 'failed', error: err.message, failedAt: Date.now() });
+
+          const errMsg1 = {
+            role: 'secretary',
+            content: `😥 Encountered a problem creating the department: ${err.message}\n\nShall we try again?`,
+            time: new Date(),
+          };
+          company.chatHistory.push(errMsg1);
+          chatStore.appendMessage(company.chatSessionId, errMsg1);
+          company.save();
+
+          setTimeout(() => runningTasks.delete(taskId), 30 * 60 * 1000);
+        }
+      })();
+
+      reply.action.taskId = taskId;
+      reply.action.taskStatus = 'running';
+    }
+
+    // If secretary returned need_new_department action, also auto-trigger create department + assign task
+    if (reply.action?.type === 'need_new_department') {
+      const taskId = `dept_task_${Date.now()}`;
+      const suggestedMission = reply.action.suggestedMission || message;
+
+      runningTasks.set(taskId, { status: 'running', type: 'create_and_assign', startedAt: Date.now() });
+
+      (async () => {
+        try {
+          // Step 1: Create department (will fallback to planDepartment since no members)
+          const dept = await company.createDepartmentDirect({
+            departmentName: 'New Project Dept',
+            mission: suggestedMission,
+            members: [],
+          });
+          console.log(`✅ Auto-created department: ${dept.name}, ${dept.agents.size} people ready`);
+
+          // Append secretary message
+          const autoCreateMsg = {
+            role: 'secretary',
+            content: `🎉 I've auto-created the "${dept.name}" department (${dept.agents.size} people), now starting task execution...`,
+            action: { type: 'department_created', departmentId: dept.id },
+            time: new Date(),
+          };
+          company.chatHistory.push(autoCreateMsg);
+          chatStore.appendMessage(company.chatSessionId, autoCreateMsg);
+          company.save();
+
+          // Step 2: Assign task
+          const summary = await company.assignTaskToDepartment(dept.id, suggestedMission);
+          runningTasks.set(taskId, { status: 'completed', summary, completedAt: Date.now() });
+          console.log(`✅ Task execution complete: ${summary.successTasks}/${summary.totalTasks}`);
+
+          setTimeout(() => runningTasks.delete(taskId), 30 * 60 * 1000);
+        } catch (err) {
+          console.error(`❌ Create department and assign task failed:`, err.message);
+          runningTasks.set(taskId, { status: 'failed', error: err.message, failedAt: Date.now() });
+
+          const errMsg2 = {
+            role: 'secretary',
+            content: `😥 Encountered a problem creating the department and assigning the task: ${err.message}\n\nPlease try creating the department manually and try again.`,
+            time: new Date(),
+          };
+          company.chatHistory.push(errMsg2);
+          chatStore.appendMessage(company.chatSessionId, errMsg2);
+          company.save();
+
+          setTimeout(() => runningTasks.delete(taskId), 30 * 60 * 1000);
+        }
+      })();
+
+      reply.action.taskId = taskId;
+      reply.action.taskStatus = 'running';
+    }
+
+    // If secretary decided to handle the task herself
+    if (reply.action?.type === 'secretary_handle') {
+      const taskId = `secretary_${Date.now()}`;
+      const { taskDescription } = reply.action;
+
+      runningTasks.set(taskId, { status: 'running', type: 'secretary_handle', startedAt: Date.now() });
+
+      // Async execution of secretary's own task
+      (async () => {
+        try {
+          const result = await company.secretary.executeTaskDirectly(taskDescription || message, company);
+
+          runningTasks.set(taskId, {
+            status: 'completed',
+            summary: { content: result.content, success: result.success },
+            completedAt: Date.now(),
+          });
+
+          // Push the result as a secretary message
+          const resultMsg = {
+            role: 'secretary',
+            content: result.content,
+            action: { type: 'secretary_task_completed', taskId },
+            time: new Date(),
+          };
+          company.chatHistory.push(resultMsg);
+          chatStore.appendMessage(company.chatSessionId, resultMsg);
+          company.save();
+
+          setTimeout(() => runningTasks.delete(taskId), 30 * 60 * 1000);
+        } catch (err) {
+          console.error(`❌ Secretary task failed:`, err.message);
+          runningTasks.set(taskId, { status: 'failed', error: err.message, failedAt: Date.now() });
+
+          const errMsg = {
+            role: 'secretary',
+            content: `😥 Encountered a problem while handling the task: ${err.message}\n\nWant me to try again?`,
+            time: new Date(),
+          };
+          company.chatHistory.push(errMsg);
+          chatStore.appendMessage(company.chatSessionId, errMsg);
+          company.save();
+
+          setTimeout(() => runningTasks.delete(taskId), 30 * 60 * 1000);
+        }
+      })();
+
+      reply.action.taskId = taskId;
+      reply.action.taskStatus = 'running';
+    }
+
+    // If secretary returned task_assigned action, auto-trigger background task execution
+    if (reply.action?.type === 'task_assigned' && reply.action.departmentId) {
+      const taskId = `task_${Date.now()}`;
+      const { departmentId, taskDescription, taskTitle } = reply.action;
+      const description = taskDescription || message; // fallback to original message
+
+      // Mark task as in progress
+      runningTasks.set(taskId, { status: 'running', departmentId, startedAt: Date.now() });
+
+      // Async task execution (non-blocking response)
+      company.assignTaskToDepartment(departmentId, description, taskTitle || null)
+        .then(summary => {
+          runningTasks.set(taskId, { status: 'completed', summary, completedAt: Date.now() });
+          console.log(`✅ Task [${taskId}] completed: ${summary.successTasks}/${summary.totalTasks} succeeded`);
+          // Clean up after 30 minutes
+          setTimeout(() => runningTasks.delete(taskId), 30 * 60 * 1000);
+        })
+        .catch(err => {
+          console.error(`❌ Task [${taskId}] failed:`, err.message);
+          runningTasks.set(taskId, { status: 'failed', error: err.message, failedAt: Date.now() });
+
+          // Append secretary message to notify boss of task failure
+          const taskFailMsg = {
+            role: 'secretary',
+            content: `❌ Task execution failed... Error: ${err.message}\n\nShall we try again?`,
+            time: new Date(),
+          };
+          company.chatHistory.push(taskFailMsg);
+          chatStore.appendMessage(company.chatSessionId, taskFailMsg);
+          company.save();
+
+          setTimeout(() => runningTasks.delete(taskId), 30 * 60 * 1000);
+        });
+
+      // Attach task ID in reply for frontend polling
+      reply.action.taskId = taskId;
+      reply.action.taskStatus = 'running';
+    }
+
+    return NextResponse.json({
+      success: true,
+      data: {
+        reply,
+        chatHistory: company.chatHistory.slice(-30),
+      },
+    });
+  } catch (e) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}
+
+export async function GET(request) {
+  const t = getApiT(request);
+  const company = getCompany();
+  if (!company) {
+    return NextResponse.json({ error: t('api.noCompany') }, { status: 400 });
+  }
+
+  // Support task status queries
+  const url = new URL(request.url);
+  const taskId = url.searchParams.get('taskId');
+
+  if (taskId) {
+    const taskState = runningTasks.get(taskId);
+    if (!taskState) {
+      return NextResponse.json({ data: { status: 'unknown' } });
+    }
+    return NextResponse.json({ data: taskState });
+  }
+
+  return NextResponse.json({
+    data: company.chatHistory.slice(-50),
+  });
+}

package/src/app/api/company/factory-reset/route.js

@@ -0,0 +1,43 @@
+import { NextResponse } from 'next/server';
+import { resetCompany } from '@/lib/store';
+import { getApiT } from '@/lib/api-i18n';
+import fs from 'fs';
+import { DATA_DIR, WORKSPACE_DIR } from '@/lib/paths.js';
+
+/**
+ * POST /api/company/factory-reset
+ * Nuclear option: wipe ALL data (company state, memories, chats, audit, workspace).
+ * This is the "restart company" high-risk operation.
+ */
+export async function POST(request) {
+  const t = getApiT(request);
+
+  try {
+    // 1. Reset in-memory company state + clear state files & memories
+    resetCompany();
+
+    // 2. Recursively remove the entire data directory (chats, audit, etc.)
+    if (fs.existsSync(DATA_DIR)) {
+      fs.rmSync(DATA_DIR, { recursive: true, force: true });
+      console.log(`🗑️ Factory reset: removed DATA_DIR (${DATA_DIR})`);
+    }
+
+    // 3. Recursively remove the entire workspace directory
+    if (fs.existsSync(WORKSPACE_DIR)) {
+      fs.rmSync(WORKSPACE_DIR, { recursive: true, force: true });
+      console.log(`🗑️ Factory reset: removed WORKSPACE_DIR (${WORKSPACE_DIR})`);
+    }
+
+    // 4. Re-create the data directory so the app can restart cleanly
+    fs.mkdirSync(DATA_DIR, { recursive: true });
+
+    return NextResponse.json({
+      success: true,
+      message: t('api.factoryResetDone'),
+      cleared: { dataDir: DATA_DIR, workspaceDir: WORKSPACE_DIR },
+    });
+  } catch (e) {
+    console.error('❌ Factory reset failed:', e);
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

package/src/app/api/company/route.js

@@ -0,0 +1,82 @@
+import { NextResponse } from 'next/server';
+import { getCompany, setCompany, resetCompany } from '@/lib/store';
+import { Company, setPromptLocale, getPromptLocaleCode } from '@/core/index.js';
+import { getApiT } from '@/lib/api-i18n';
+
+export async function GET() {
+  const company = getCompany();
+  return NextResponse.json({ data: company ? company.getFullState() : null, promptLocale: getPromptLocaleCode() });
+}
+
+export async function POST(request) {
+  const t = getApiT(request);
+  try {
+    const { companyName, bossName, secretaryConfig, promptLocale } = await request.json();
+    if (!companyName) {
+      return NextResponse.json({ error: t('api.companyNameRequired') }, { status: 400 });
+    }
+    // Set prompt locale for AI employee chat (default: 'en')
+    if (promptLocale) {
+      setPromptLocale(promptLocale);
+    }
+    const company = new Company(companyName, bossName || 'Boss', {
+      ...secretaryConfig,
+      secretaryName: secretaryConfig?.secretaryName,
+      secretaryAvatar: secretaryConfig?.secretaryAvatar,
+    });
+    // Set boss avatar if provided during creation
+    if (secretaryConfig?.bossAvatar) {
+      company.bossAvatar = secretaryConfig.bossAvatar;
+    }
+    setCompany(company);
+    return NextResponse.json({ success: true, data: company.getFullState() });
+  } catch (e) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}
+
+/**
+ * DELETE /api/company - Reset company (clear persisted data)
+ */
+export async function DELETE(request) {
+  const t = getApiT(request);
+  resetCompany();
+  return NextResponse.json({ success: true, message: t('api.companyDissolved') });
+}
+
+/**
+ * PUT /api/company - Update company settings (e.g., boss avatar)
+ */
+export async function PUT(request) {
+  const t = getApiT(request);
+  const company = getCompany();
+  if (!company) {
+    return NextResponse.json({ error: t('api.noCompany') }, { status: 400 });
+  }
+  try {
+    const body = await request.json();
+    // Support prompt locale change via PUT
+    if (body.promptLocale) {
+      setPromptLocale(body.promptLocale);
+    }
+    if (typeof company.updateBossProfile !== 'function') {
+      // Fallback: server might have a stale instance without this method, apply directly
+      if (body.avatar) company.bossAvatar = body.avatar;
+      const { saveState } = await import('@/core/organization/persistence.js');
+      saveState(company);
+      return NextResponse.json({
+        success: true,
+        data: { bossAvatar: company.bossAvatar },
+        fullState: company.getFullState(),
+      });
+    }
+    const result = company.updateBossProfile(body);
+    return NextResponse.json({
+      success: true,
+      data: result,
+      fullState: company.getFullState(),
+    });
+  } catch (e) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

package/src/app/api/departments/[deptId]/agents/[agentId]/dismiss/route.js

@@ -0,0 +1,19 @@
+import { NextResponse } from 'next/server';
+import { getCompany } from '@/lib/store';
+import { getApiT } from '@/lib/api-i18n';
+
+export async function POST(request, { params }) {
+  const t = getApiT(request);
+  const company = getCompany();
+  if (!company) return NextResponse.json({ error: t('api.noCompany') }, { status: 400 });
+
+  try {
+    const { deptId, agentId } = await params;
+    const { reason } = await request.json();
+    company.dismissAgent(deptId, agentId, reason || 'Dismissed by boss');
+    company._log('Dismiss employee', `Employee dismissed`);
+    return NextResponse.json({ success: true, data: company.getFullState() });
+  } catch (e) {
+    return NextResponse.json({ error: e.message }, { status: 400 });
+  }
+}

package/src/app/api/departments/route.js

@@ -0,0 +1,92 @@
+import { NextResponse } from 'next/server';
+import { getCompany } from '@/lib/store';
+import { getApiT } from '@/lib/api-i18n';
+
+/**
+ * POST /api/departments - Department operations
+ * action=undefined: Generate recruitment plan
+ * action=confirm: Confirm recruitment plan
+ * action=adjust: Generate adjustment plan
+ * action=confirmAdjust: Confirm adjustment plan
+ * action=disband: Disband department
+ */
+export async function POST(request) {
+  const t = getApiT(request);
+  const company = getCompany();
+  if (!company) return NextResponse.json({ error: t('api.noCompany') }, { status: 400 });
+
+  try {
+    const url = new URL(request.url);
+    const action = url.searchParams.get('action');
+
+    if (action === 'confirm') {
+      // Confirm recruitment plan
+      const { planId } = await request.json();
+      if (!planId) {
+        return NextResponse.json({ error: t('api.planIdRequired') }, { status: 400 });
+      }
+      const dept = await company.confirmPlan(planId);
+      return NextResponse.json({ success: true, data: company.getFullState() });
+
+    } else if (action === 'adjust') {
+      // Generate adjustment plan
+      const { departmentId, adjustGoal } = await request.json();
+      if (!departmentId || !adjustGoal) {
+        return NextResponse.json({ error: t('api.deptIdAdjustGoalRequired') }, { status: 400 });
+      }
+      const plan = await company.planAdjustment(departmentId, adjustGoal);
+      return NextResponse.json({ success: true, data: plan });
+
+    } else if (action === 'confirmAdjust') {
+      // Confirm adjustment plan
+      const { planId } = await request.json();
+      if (!planId) {
+        return NextResponse.json({ error: t('api.adjustPlanIdRequired') }, { status: 400 });
+      }
+      await company.confirmAdjustment(planId);
+      return NextResponse.json({ success: true, data: company.getFullState() });
+
+    } else if (action === 'disband') {
+      // Disband department
+      const { departmentId, reason } = await request.json();
+      if (!departmentId) {
+        return NextResponse.json({ error: t('api.deptIdRequired') }, { status: 400 });
+      }
+      const result = company.disbandDepartment(departmentId, reason || 'Boss decision');
+      return NextResponse.json({ success: true, data: company.getFullState(), result });
+
+    } else if (action === 'boss_message') {
+      // Boss sends message to department group chat
+      const { departmentId, message } = await request.json();
+      if (!departmentId || !message) {
+        return NextResponse.json({ error: t('api.deptIdMessageRequired') }, { status: 400 });
+      }
+      const result = company.sendBossDeptGroupMessage(departmentId, message);
+      return NextResponse.json({ success: true, data: result });
+
+    } else if (action === 'dept_chat') {
+      // Get department group chat messages
+      const { departmentId } = await request.json();
+      if (!departmentId) {
+        return NextResponse.json({ error: t('api.deptIdRequired') }, { status: 400 });
+      }
+      const dept = company.findDepartment(departmentId);
+      if (!dept) {
+        return NextResponse.json({ error: t('api.deptNotFound') }, { status: 404 });
+      }
+      return NextResponse.json({ success: true, data: { groupChat: dept.groupChat || [] } });
+
+    } else {
+      // Generate recruitment plan
+      const { name, mission } = await request.json();
+      if (!name || !mission) {
+        return NextResponse.json({ error: t('api.deptNameMissionRequired') }, { status: 400 });
+      }
+      const plan = await company.planDepartment(name, mission);
+      return NextResponse.json({ success: true, data: plan });
+    }
+  } catch (e) {
+    console.error('Department operation failed:', e);
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

package/src/app/api/group-chat-loop/events/route.js

@@ -0,0 +1,70 @@
+import { groupChatLoop } from '@/core/organization/group-chat-loop.js';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * SSE endpoint for real-time monologue (flow) events.
+ *
+ * GET /api/group-chat-loop/events
+ *
+ * Pushes:
+ *   - monologue:start  { agentId, agentName, groupId }
+ *   - monologue:end    { agentId, agentName, groupId, decision, thoughtCount, thoughts, reason }
+ *   - snapshot         (initial full state on connect)
+ */
+export async function GET() {
+  const encoder = new TextEncoder();
+
+  const stream = new ReadableStream({
+    start(controller) {
+      const send = (event, data) => {
+        try {
+          controller.enqueue(encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`));
+        } catch { /* client disconnected */ }
+      };
+
+      // Send initial snapshot so client immediately knows who is thinking
+      const snapshot = groupChatLoop.getActiveThinkingAgents();
+      send('snapshot', snapshot);
+
+      // Listen to lifecycle events
+      const onStart = (data) => send('monologue:start', data);
+      const onEnd = (data) => send('monologue:end', data);
+
+      groupChatLoop.on('monologue:start', onStart);
+      groupChatLoop.on('monologue:end', onEnd);
+
+      // Keep-alive every 30s to prevent proxy/browser timeout
+      const keepAlive = setInterval(() => {
+        try {
+          controller.enqueue(encoder.encode(': keep-alive\n\n'));
+        } catch {
+          clearInterval(keepAlive);
+        }
+      }, 30000);
+
+      // Cleanup when client disconnects
+      const cleanup = () => {
+        groupChatLoop.off('monologue:start', onStart);
+        groupChatLoop.off('monologue:end', onEnd);
+        clearInterval(keepAlive);
+      };
+
+      // AbortSignal isn't available here, but we detect enqueue failure above.
+      // Store cleanup for the cancel() callback.
+      controller._cleanup = cleanup;
+    },
+    cancel(controller) {
+      controller?._cleanup?.();
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache, no-transform',
+      'Connection': 'keep-alive',
+      'X-Accel-Buffering': 'no',
+    },
+  });
+}