ideaco 1.1.5

package/src/app/api/system/cli-backends/route.js

@@ -0,0 +1,91 @@
+/**
+ * CLI Backends API - Manage CLI backends (detect, register, configure)
+ */
+import { NextResponse } from 'next/server';
+import { cliBackendRegistry } from '@/core/agent/cli-agent/backends/index.js';
+import { getCompany } from '@/lib/store';
+import { getApiT } from '@/lib/api-i18n';
+
+/**
+ * GET /api/system/cli-backends
+ * Get all CLI backend statuses
+ */
+export async function GET() {
+  try {
+    const backends = cliBackendRegistry.listAll();
+    return NextResponse.json({ data: backends });
+  } catch (error) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}
+
+/**
+ * POST /api/system/cli-backends
+ * CLI backend management operations
+ * 
+ * Actions:
+ * - detect: detect all CLIs
+ * - detectOne: detect a single CLI
+ * - register: register a custom CLI
+ * - unregister: remove a custom CLI
+ */
+export async function POST(request) {
+  const t = getApiT(request);
+  try {
+    const body = await request.json();
+    const { action } = body;
+
+    switch (action) {
+      case 'detect': {
+        const results = await cliBackendRegistry.detectAll();
+        // Sync detected CLI backends into provider registry
+        const company = getCompany();
+        if (company) {
+          company.providerRegistry.syncCLIBackends(cliBackendRegistry);
+        }
+        return NextResponse.json({ data: results });
+      }
+
+      case 'detectOne': {
+        const { backendId } = body;
+        if (!backendId) {
+          return NextResponse.json({ error: t('api.missingBackendId') }, { status: 400 });
+        }
+        const result = await cliBackendRegistry.detect(backendId);
+        return NextResponse.json({ data: { id: backendId, ...result } });
+      }
+
+      case 'register': {
+        const { config } = body;
+        if (!config || !config.id || !config.execCommand) {
+          return NextResponse.json({ error: t('api.cliConfigRequired') }, { status: 400 });
+        }
+        const registered = cliBackendRegistry.register(config);
+        // Detect immediately after registration
+        await cliBackendRegistry.detect(registered.id);
+        // Sync to provider registry
+        const company2 = getCompany();
+        if (company2) {
+          company2.providerRegistry.syncCLIBackends(cliBackendRegistry);
+        }
+        const backends = cliBackendRegistry.listAll();
+        return NextResponse.json({ data: backends });
+      }
+
+      case 'unregister': {
+        const { backendId } = body;
+        if (!backendId) {
+          return NextResponse.json({ error: t('api.missingBackendId') }, { status: 400 });
+        }
+        cliBackendRegistry.unregister(backendId);
+        const backends = cliBackendRegistry.listAll();
+        return NextResponse.json({ data: backends });
+      }
+
+      default:
+        return NextResponse.json({ error: t('api.pluginUnknownAction', { action }) }, { status: 400 });
+    }
+  } catch (error) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}

package/src/app/api/system/cron/route.js

@@ -0,0 +1,110 @@
+import { NextResponse } from 'next/server';
+import { getCompany } from '@/lib/store';
+import { cronScheduler } from '@/core/system/cron.js';
+import { getApiT } from '@/lib/api-i18n';
+
+/**
+ * GET /api/system/cron - List all cron jobs
+ */
+export async function GET() {
+  try {
+    return NextResponse.json({
+      data: {
+        summary: cronScheduler.getSummary(),
+        jobs: cronScheduler.listJobs(),
+      },
+    });
+  } catch (error) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}
+
+/**
+ * POST /api/system/cron - Manage cron jobs
+ * 
+ * Actions:
+ * - create: { name, cronExpression, agentId, taskPrompt, description? }
+ * - pause: { jobId }
+ * - resume: { jobId }
+ * - trigger: { jobId }
+ * - delete: { jobId }
+ */
+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 body = await request.json();
+    const { action = 'create' } = body;
+
+    switch (action) {
+      case 'create': {
+        const { name, cronExpression, agentId, taskPrompt, description } = body;
+        if (!name || !cronExpression || !agentId || !taskPrompt) {
+          return NextResponse.json(
+            { error: t('api.cronMissingFields') },
+            { status: 400 }
+          );
+        }
+
+        // Verify agent exists
+        let agentFound = false;
+        for (const dept of company.departments.values()) {
+          if (dept.agents.has(agentId)) {
+            agentFound = true;
+            break;
+          }
+        }
+        if (!agentFound) {
+          return NextResponse.json({ error: t('api.agentNotFoundId', { id: agentId }) }, { status: 404 });
+        }
+
+        const job = cronScheduler.addJob({
+          name,
+          cronExpression,
+          agentId,
+          taskPrompt,
+          description: description || '',
+        });
+
+        return NextResponse.json({
+          data: {
+            id: job.id,
+            name: job.name,
+            cronExpression: job.cronExpression,
+            nextRun: job.nextRun?.toISOString(),
+            status: job.status,
+          },
+        });
+      }
+
+      case 'pause': {
+        cronScheduler.pauseJob(body.jobId);
+        return NextResponse.json({ data: { success: true } });
+      }
+
+      case 'resume': {
+        cronScheduler.resumeJob(body.jobId);
+        return NextResponse.json({ data: { success: true } });
+      }
+
+      case 'trigger': {
+        await cronScheduler.triggerJob(body.jobId);
+        return NextResponse.json({ data: { success: true } });
+      }
+
+      case 'delete': {
+        cronScheduler.removeJob(body.jobId);
+        return NextResponse.json({ data: { success: true } });
+      }
+
+      default:
+        return NextResponse.json({ error: t('api.pluginUnknownAction', { action }) }, { status: 400 });
+    }
+  } catch (error) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}

package/src/app/api/system/knowledge/route.js

@@ -0,0 +1,104 @@
+import { NextResponse } from 'next/server';
+import { knowledgeManager, KnowledgeType, EntryType } from '@/core/employee/knowledge.js';
+import { getApiT } from '@/lib/api-i18n';
+
+/**
+ * GET /api/system/knowledge - Get knowledge base list or search
+ */
+export async function GET(request) {
+  const t = getApiT(request);
+  try {
+    const { searchParams } = new URL(request.url);
+    const query = searchParams.get('query');
+    const kbId = searchParams.get('kbId');
+
+    // Search
+    if (query) {
+      const results = knowledgeManager.search(query, { limit: 20 });
+      return NextResponse.json({ data: results });
+    }
+
+    // Get entries for a specific knowledge base
+    if (kbId) {
+      const kb = knowledgeManager.get(kbId);
+      if (!kb) return NextResponse.json({ error: t('api.kbNotFound') }, { status: 404 });
+      return NextResponse.json({
+        data: {
+          id: kb.id,
+          name: kb.name,
+          description: kb.description,
+          type: kb.type,
+          enabled: kb.enabled,
+          entries: kb.listEntries(),
+          stats: kb.getStats(),
+        },
+      });
+    }
+
+    // List all knowledge bases
+    return NextResponse.json({
+      data: {
+        bases: knowledgeManager.list(),
+        stats: knowledgeManager.getOverallStats(),
+        types: KnowledgeType,
+        entryTypes: EntryType,
+      },
+    });
+  } catch (error) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}
+
+/**
+ * POST /api/system/knowledge - Knowledge base management operations
+ * Actions: create, addEntry, removeEntry, delete, toggle
+ */
+export async function POST(request) {
+  const t = getApiT(request);
+  try {
+    const body = await request.json();
+    const { action } = body;
+
+    switch (action) {
+      case 'create': {
+        const kb = knowledgeManager.create({
+          name: body.name,
+          description: body.description,
+          type: body.type || KnowledgeType.GLOBAL,
+          ownerId: body.ownerId || null,
+        });
+        return NextResponse.json({ data: { id: kb.id, success: true } });
+      }
+      case 'addEntry': {
+        const entry = knowledgeManager.addEntry(body.kbId, {
+          title: body.title,
+          content: body.content,
+          type: body.entryType || EntryType.NOTE,
+          tags: body.tags || [],
+          importance: body.importance || 0.5,
+          source: body.source || null,
+          createdBy: body.createdBy || null,
+        });
+        return NextResponse.json({ data: { id: entry.id, success: true } });
+      }
+      case 'removeEntry': {
+        const result = knowledgeManager.removeEntry(body.kbId, body.entryId);
+        return NextResponse.json({ data: { success: result } });
+      }
+      case 'delete': {
+        const result = knowledgeManager.delete(body.kbId);
+        return NextResponse.json({ data: { success: result } });
+      }
+      case 'toggle': {
+        const kb = knowledgeManager.get(body.kbId);
+        if (!kb) return NextResponse.json({ error: t('api.kbNotFound') }, { status: 404 });
+        kb.enabled = !kb.enabled;
+        return NextResponse.json({ data: { success: true, enabled: kb.enabled } });
+      }
+      default:
+        return NextResponse.json({ error: t('api.kbUnknownAction', { action }) }, { status: 400 });
+    }
+  } catch (error) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}

package/src/app/api/system/plugins/route.js

@@ -0,0 +1,40 @@
+import { NextResponse } from 'next/server';
+import { pluginRegistry } from '@/core/system/plugin.js';
+import { getApiT } from '@/lib/api-i18n';
+
+/**
+ * GET /api/system/plugins - List all plugins
+ */
+export async function GET() {
+  try {
+    return NextResponse.json({ data: pluginRegistry.list() });
+  } catch (error) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}
+
+/**
+ * POST /api/system/plugins - Manage plugins
+ * Actions: enable, disable
+ */
+export async function POST(request) {
+  const t = getApiT(request);
+  try {
+    const { action, pluginId } = await request.json();
+    if (!pluginId) {
+      return NextResponse.json({ error: t('api.missingPluginId') }, { status: 400 });
+    }
+    switch (action) {
+      case 'enable':
+        pluginRegistry.enable(pluginId);
+        return NextResponse.json({ data: { success: true } });
+      case 'disable':
+        pluginRegistry.disable(pluginId);
+        return NextResponse.json({ data: { success: true } });
+      default:
+        return NextResponse.json({ error: t('api.pluginUnknownAction', { action }) }, { status: 400 });
+    }
+  } catch (error) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}

package/src/app/api/system/skills/route.js

@@ -0,0 +1,46 @@
+import { NextResponse } from 'next/server';
+import { skillRegistry } from '@/core/employee/skills.js';
+import { getApiT } from '@/lib/api-i18n';
+
+/**
+ * GET /api/system/skills - Get all skills
+ */
+export async function GET() {
+  try {
+    return NextResponse.json({ data: skillRegistry.list() });
+  } catch (error) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}
+
+/**
+ * POST /api/system/skills - Manage skills
+ * Actions: enable, disable, configure
+ */
+export async function POST(request) {
+  const t = getApiT(request);
+  try {
+    const { action, skillId, config } = await request.json();
+    if (!skillId) {
+      return NextResponse.json({ error: t('api.missingSkillId') }, { status: 400 });
+    }
+    switch (action) {
+      case 'enable':
+        skillRegistry.enable(skillId);
+        return NextResponse.json({ data: { success: true } });
+      case 'disable':
+        skillRegistry.disable(skillId);
+        return NextResponse.json({ data: { success: true } });
+      case 'install':
+        skillRegistry.install(skillId, config || {});
+        return NextResponse.json({ data: { success: true } });
+      case 'configure':
+        skillRegistry.configure(skillId, config || {});
+        return NextResponse.json({ data: { success: true } });
+      default:
+        return NextResponse.json({ error: t('api.pluginUnknownAction', { action }) }, { status: 400 });
+    }
+  } catch (error) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}

package/src/app/api/system/status/route.js

@@ -0,0 +1,46 @@
+import { NextResponse } from 'next/server';
+import { auditLogger, securityGuard } from '@/core/system/audit.js';
+import { pluginRegistry } from '@/core/system/plugin.js';
+import { cronScheduler } from '@/core/system/cron.js';
+import { hookRegistry } from '@/lib/hooks.js';
+import { sessionManager } from '@/core/agent/session.js';
+import { configValidator } from '@/lib/config-validator.js';
+
+/**
+ * GET /api/system/status - System status dashboard
+ * Returns health of all distilled systems: audit, routing, plugins, cron, hooks, sessions, config
+ */
+export async function GET() {
+  try {
+    const status = {
+      // Audit system summary
+      audit: auditLogger.getSummary(),
+
+      // Plugin system status
+      plugins: pluginRegistry.list(),
+
+      // Cron scheduler status
+      cron: cronScheduler.getSummary(),
+      cronJobs: cronScheduler.listJobs(),
+
+      // Hook system status
+      hooks: hookRegistry.getSummary(),
+
+      // Session manager status
+      sessions: sessionManager.getSummary(),
+
+      // Config validator (validate current empty config as health check)
+      configHealth: {
+        schemaFields: Object.keys(configValidator.schema.properties || {}),
+      },
+
+      // Recent security events
+      recentAuditEvents: auditLogger.query({ limit: 20 }),
+      blockedActions: auditLogger.query({ blocked: true, limit: 10 }),
+    };
+
+    return NextResponse.json({ data: status });
+  } catch (error) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}

package/src/app/api/talent-market/[profileId]/recall/route.js

@@ -0,0 +1,22 @@
+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 { profileId } = await params;
+    const { departmentId, newSkills } = await request.json();
+    if (!departmentId) {
+      return NextResponse.json({ error: t('api.targetDeptRequired') }, { status: 400 });
+    }
+    company.recallAgent(departmentId, profileId, newSkills || []);
+    company._log('Recall talent', `Recalled employee from talent market`);
+    return NextResponse.json({ success: true, data: company.getFullState() });
+  } catch (e) {
+    return NextResponse.json({ error: e.message }, { status: 400 });
+  }
+}

package/src/app/api/talent-market/[profileId]/route.js

@@ -0,0 +1,17 @@
+import { NextResponse } from 'next/server';
+import { getCompany } from '@/lib/store';
+import { getApiT } from '@/lib/api-i18n';
+
+export async function DELETE(request, { params }) {
+  const t = getApiT(request);
+  const company = getCompany();
+  if (!company) return NextResponse.json({ error: t('api.noCompany') }, { status: 400 });
+
+  try {
+    const { profileId } = await params;
+    company.deleteTalent(profileId);
+    return NextResponse.json({ success: true, data: company.getFullState() });
+  } catch (e) {
+    return NextResponse.json({ error: e.message }, { status: 400 });
+  }
+}

package/src/app/api/talent-market/route.js

@@ -0,0 +1,26 @@
+import { NextResponse } from 'next/server';
+import { getCompany } from '@/lib/store';
+import { getApiT } from '@/lib/api-i18n';
+
+export async function GET(request) {
+  const t = getApiT(request);
+  const company = getCompany();
+  if (!company) return NextResponse.json({ error: t('api.noCompany') }, { status: 400 });
+
+  const market = company.talentMarket.listAvailable().map(p => ({
+    id: p.id,
+    name: p.name,
+    role: p.role,
+    skills: [...p.skills, ...p.acquiredSkills],
+    acquiredSkills: p.acquiredSkills,
+    dismissalReason: p.dismissalReason,
+    performanceScore: p.performanceData?.averageScore,
+    registeredAt: p.registeredAt,
+    workHistory: p.workHistory,
+    memoryCount: p.memorySnapshot
+      ? (p.memorySnapshot.shortTerm?.length || 0) + (p.memorySnapshot.longTerm?.length || 0)
+      : 0,
+  }));
+
+  return NextResponse.json({ data: market });
+}