ideaco 1.1.5

package/src/lib/hooks.js

@@ -0,0 +1,414 @@
+/**
+ * Lifecycle Hook System - Event-driven extensibility framework
+ *
+ * Distilled from OpenClaw's hook system (vendor/openclaw/src/hooks/internal-hooks.ts)
+ * Re-implemented as an enterprise "business process automation" hook system
+ *
+ * Features:
+ * - Type-safe event registration and triggering
+ * - Wildcard and specific event:action subscriptions
+ * - Error isolation (one handler failure doesn't block others)
+ * - Hook priority ordering
+ * - Async handler support with timeout protection
+ * - Debug introspection for registered hooks
+ */
+
+/**
+ * Hook event types — the broad categories of lifecycle events
+ */
+export const HookEventType = {
+  AGENT: 'agent',
+  TASK: 'task',
+  REQUIREMENT: 'requirement',
+  DEPARTMENT: 'department',
+  SYSTEM: 'system',
+  MESSAGE: 'message',
+  LLM: 'llm',
+};
+
+/**
+ * Pre-defined hook event keys (type:action combinations)
+ */
+export const HookEvent = {
+  // Agent lifecycle
+  AGENT_CREATED: 'agent:created',
+  AGENT_TASK_START: 'agent:task_start',
+  AGENT_TASK_END: 'agent:task_end',
+  AGENT_DISMISSED: 'agent:dismissed',
+  AGENT_ERROR: 'agent:error',
+
+  // Task lifecycle
+  TASK_ASSIGNED: 'task:assigned',
+  TASK_PROGRESS: 'task:progress',
+  TASK_COMPLETED: 'task:completed',
+  TASK_FAILED: 'task:failed',
+  TASK_REVIEW: 'task:review',
+
+  // Requirement lifecycle
+  REQ_CREATED: 'requirement:created',
+  REQ_TEAM_FORMED: 'requirement:team_formed',
+  REQ_PHASE_START: 'requirement:phase_start',
+  REQ_PHASE_END: 'requirement:phase_end',
+  REQ_COMPLETED: 'requirement:completed',
+  REQ_CANCELLED: 'requirement:cancelled',
+
+  // Department lifecycle
+  DEPT_CREATED: 'department:created',
+  DEPT_MEMBER_ADDED: 'department:member_added',
+  DEPT_MEMBER_REMOVED: 'department:member_removed',
+
+  // System events
+  SYSTEM_STARTUP: 'system:startup',
+  SYSTEM_SHUTDOWN: 'system:shutdown',
+  SYSTEM_HEALTH_CHECK: 'system:health_check',
+  SYSTEM_CONFIG_CHANGE: 'system:config_change',
+
+  // Message events
+  MESSAGE_RECEIVED: 'message:received',
+  MESSAGE_SENT: 'message:sent',
+  MESSAGE_BROADCAST: 'message:broadcast',
+
+  // LLM interaction events
+  LLM_REQUEST_START: 'llm:request_start',
+  LLM_REQUEST_END: 'llm:request_end',
+  LLM_TOKEN_USAGE: 'llm:token_usage',
+  LLM_ERROR: 'llm:error',
+};
+
+/**
+ * Default handler timeout (ms)
+ */
+const DEFAULT_TIMEOUT = 10000;
+
+/**
+ * Internal handler entry with metadata
+ * @typedef {object} HandlerEntry
+ * @property {string} id - Unique handler ID
+ * @property {Function} handler - The actual handler function
+ * @property {number} priority - Execution priority (lower = first)
+ * @property {string} source - Who registered this handler (plugin ID, module name, etc.)
+ * @property {number} timeout - Max execution time in ms
+ * @property {Date} registeredAt - When this handler was registered
+ */
+
+/**
+ * Hook Event Payload - passed to every handler
+ * @typedef {object} HookEventPayload
+ * @property {string} type - Event type (agent, task, etc.)
+ * @property {string} action - Specific action (created, completed, etc.)
+ * @property {string} eventKey - Full event key (type:action)
+ * @property {object} context - Event-specific context data
+ * @property {Date} timestamp - When the event occurred
+ * @property {string[]} messages - Handlers can push messages here for feedback
+ * @property {object} meta - Mutable metadata that handlers can enrich
+ */
+
+let handlerIdCounter = 0;
+
+/**
+ * Hook Registry - Manages all lifecycle hooks
+ *
+ * Uses a singleton pattern (similar to OpenClaw's globalThis approach)
+ * to ensure hooks work across dynamic imports.
+ */
+class HookRegistry {
+  constructor() {
+    /** @type {Map<string, HandlerEntry[]>} */
+    this.handlers = new Map();
+
+    /** @type {Map<string, number>} - Track how many times each event has fired */
+    this.eventCounts = new Map();
+
+    /** @type {Array<{eventKey: string, timestamp: Date, handlerCount: number, errors: number}>} */
+    this.recentFires = [];
+    this.maxRecentFires = 100;
+  }
+
+  /**
+   * Register a hook handler for a specific event key
+   *
+   * @param {string} eventKey - Event type (e.g., 'agent') or specific (e.g., 'agent:created')
+   * @param {Function} handler - async (event: HookEventPayload) => void
+   * @param {object} options
+   * @param {number} options.priority - Execution priority (default: 100, lower = first)
+   * @param {string} options.source - Who registered this (for debugging)
+   * @param {number} options.timeout - Handler timeout in ms
+   * @returns {string} Handler ID for later removal
+   *
+   * @example
+   * // Listen to all agent events
+   * hookRegistry.on('agent', async (event) => {
+   *   console.log('Agent event:', event.action);
+   * });
+   *
+   * // Listen to specific task completion
+   * hookRegistry.on('task:completed', async (event) => {
+   *   await notifyStakeholders(event.context);
+   * });
+   */
+  on(eventKey, handler, options = {}) {
+    const id = `hook_${++handlerIdCounter}`;
+    const entry = {
+      id,
+      handler,
+      priority: options.priority ?? 100,
+      source: options.source || 'unknown',
+      timeout: options.timeout ?? DEFAULT_TIMEOUT,
+      registeredAt: new Date(),
+    };
+
+    if (!this.handlers.has(eventKey)) {
+      this.handlers.set(eventKey, []);
+    }
+
+    const list = this.handlers.get(eventKey);
+    list.push(entry);
+
+    // Keep sorted by priority (lower first)
+    list.sort((a, b) => a.priority - b.priority);
+
+    return id;
+  }
+
+  /**
+   * Remove a specific handler by its ID
+   * @param {string} handlerId
+   * @returns {boolean} Whether the handler was found and removed
+   */
+  off(handlerId) {
+    for (const [eventKey, entries] of this.handlers) {
+      const index = entries.findIndex(e => e.id === handlerId);
+      if (index !== -1) {
+        entries.splice(index, 1);
+        if (entries.length === 0) {
+          this.handlers.delete(eventKey);
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Remove all handlers for an event key
+   * @param {string} eventKey
+   */
+  offAll(eventKey) {
+    this.handlers.delete(eventKey);
+  }
+
+  /**
+   * Remove all handlers from a specific source
+   * @param {string} source
+   * @returns {number} Number of handlers removed
+   */
+  offBySource(source) {
+    let removed = 0;
+    for (const [eventKey, entries] of this.handlers) {
+      const before = entries.length;
+      const filtered = entries.filter(e => e.source !== source);
+      if (filtered.length !== before) {
+        removed += before - filtered.length;
+        if (filtered.length === 0) {
+          this.handlers.delete(eventKey);
+        } else {
+          this.handlers.set(eventKey, filtered);
+        }
+      }
+    }
+    return removed;
+  }
+
+  /**
+   * Trigger a hook event
+   *
+   * Calls all handlers registered for:
+   * 1. The general event type (e.g., 'agent')
+   * 2. The specific event:action combination (e.g., 'agent:created')
+   *
+   * Handlers execute in priority order. Errors are caught and logged
+   * but don't prevent other handlers from running.
+   *
+   * @param {string} eventKey - The event key (e.g., 'agent:created')
+   * @param {object} context - Event-specific context data
+   * @returns {Promise<{messages: string[], errors: Array<{handlerId: string, source: string, error: string}>, meta: object}>}
+   */
+  async trigger(eventKey, context = {}) {
+    const [type, action] = eventKey.includes(':')
+      ? eventKey.split(':', 2)
+      : [eventKey, 'unknown'];
+
+    const event = {
+      type,
+      action,
+      eventKey,
+      context,
+      timestamp: new Date(),
+      messages: [],
+      meta: {},
+    };
+
+    // Collect handlers: type-level + specific event key
+    const typeHandlers = this.handlers.get(type) || [];
+    const specificHandlers = eventKey !== type
+      ? (this.handlers.get(eventKey) || [])
+      : [];
+
+    // Merge and sort by priority
+    const allHandlers = [...typeHandlers, ...specificHandlers]
+      .sort((a, b) => a.priority - b.priority);
+
+    // Track event firing
+    this.eventCounts.set(eventKey, (this.eventCounts.get(eventKey) || 0) + 1);
+
+    const errors = [];
+
+    if (allHandlers.length === 0) {
+      this._recordFire(eventKey, 0, 0);
+      return { messages: event.messages, errors, meta: event.meta };
+    }
+
+    // Execute handlers sequentially (in priority order)
+    for (const entry of allHandlers) {
+      try {
+        const result = await this._executeWithTimeout(
+          entry.handler,
+          event,
+          entry.timeout,
+        );
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`[Hooks] Error in handler "${entry.id}" (${entry.source}) for ${eventKey}: ${message}`);
+        errors.push({
+          handlerId: entry.id,
+          source: entry.source,
+          error: message,
+        });
+      }
+    }
+
+    this._recordFire(eventKey, allHandlers.length, errors.length);
+
+    return { messages: event.messages, errors, meta: event.meta };
+  }
+
+  /**
+   * Execute a handler with timeout protection
+   * @param {Function} handler
+   * @param {object} event
+   * @param {number} timeoutMs
+   * @returns {Promise<void>}
+   */
+  async _executeWithTimeout(handler, event, timeoutMs) {
+    return Promise.race([
+      handler(event),
+      new Promise((_, reject) =>
+        setTimeout(
+          () => reject(new Error(`Hook handler timed out after ${timeoutMs}ms`)),
+          timeoutMs,
+        ),
+      ),
+    ]);
+  }
+
+  /**
+   * Record a fire event for introspection
+   */
+  _recordFire(eventKey, handlerCount, errors) {
+    this.recentFires.push({
+      eventKey,
+      timestamp: new Date(),
+      handlerCount,
+      errors,
+    });
+    if (this.recentFires.length > this.maxRecentFires) {
+      this.recentFires.shift();
+    }
+  }
+
+  /**
+   * Clear all registered hooks (useful for testing)
+   */
+  clear() {
+    this.handlers.clear();
+    this.eventCounts.clear();
+    this.recentFires = [];
+  }
+
+  /**
+   * Get all registered event keys (for debugging)
+   * @returns {string[]}
+   */
+  getRegisteredKeys() {
+    return Array.from(this.handlers.keys());
+  }
+
+  /**
+   * Get handler count for a specific event key
+   * @param {string} eventKey
+   * @returns {number}
+   */
+  getHandlerCount(eventKey) {
+    return (this.handlers.get(eventKey) || []).length;
+  }
+
+  /**
+   * Get full diagnostic summary
+   * @returns {object}
+   */
+  getSummary() {
+    const keys = this.getRegisteredKeys();
+    const handlersByKey = {};
+    let totalHandlers = 0;
+
+    for (const key of keys) {
+      const entries = this.handlers.get(key) || [];
+      handlersByKey[key] = entries.map(e => ({
+        id: e.id,
+        source: e.source,
+        priority: e.priority,
+      }));
+      totalHandlers += entries.length;
+    }
+
+    return {
+      totalHandlers,
+      registeredKeys: keys.length,
+      handlersByKey,
+      eventCounts: Object.fromEntries(this.eventCounts),
+      recentFires: this.recentFires.slice(-20),
+    };
+  }
+}
+
+// ============================================================================
+// Convenience factory for creating hook event payloads
+// ============================================================================
+
+/**
+ * Create a hook event payload with common fields filled in
+ *
+ * @param {string} type - Event type
+ * @param {string} action - Action within that type
+ * @param {object} context - Additional context
+ * @returns {HookEventPayload}
+ */
+export function createHookEvent(type, action, context = {}) {
+  return {
+    type,
+    action,
+    eventKey: `${type}:${action}`,
+    context,
+    timestamp: new Date(),
+    messages: [],
+    meta: {},
+  };
+}
+
+// ============================================================================
+// Global singleton
+// ============================================================================
+
+export const hookRegistry = new HookRegistry();
+
+export { HookRegistry };

package/src/lib/i18n.js

@@ -0,0 +1,134 @@
+
+'use client';
+
+import { createContext, useContext, useState, useEffect, useCallback, useRef } from 'react';
+import en from '@/locales/en';
+import zh from '@/locales/zh';
+import ja from '@/locales/ja';
+import ko from '@/locales/ko';
+import es from '@/locales/es';
+import fr from '@/locales/fr';
+import de from '@/locales/de';
+
+const translations = { en, zh, ja, ko, es, fr, de };
+
+export const LANGUAGES = [
+  { code: 'en', label: 'English', flag: '🇺🇸' },
+  { code: 'zh', label: '中文', flag: '🇨🇳' },
+  { code: 'ja', label: '日本語', flag: '🇯🇵' },
+  { code: 'ko', label: '한국어', flag: '🇰🇷' },
+  { code: 'es', label: 'Español', flag: '🇪🇸' },
+  { code: 'fr', label: 'Français', flag: '🇫🇷' },
+  { code: 'de', label: 'Deutsch', flag: '🇩🇪' },
+];
+
+const DEFAULT_LANG = 'en';
+
+const I18nContext = createContext(null);
+
+function getNestedValue(obj, path) {
+  return path.split('.').reduce((o, k) => o?.[k], obj);
+}
+
+export function I18nProvider({ children }) {
+  const [lang, setLangState] = useState(DEFAULT_LANG);
+
+  useEffect(() => {
+const saved = localStorage.getItem('idea-unlimited-lang');
+    if (saved && translations[saved]) {
+      setLangState(saved);
+    }
+  }, []);
+
+  const setLang = useCallback((code) => {
+    if (translations[code]) {
+      setLangState(code);
+localStorage.setItem('idea-unlimited-lang', code);
+      document.documentElement.lang = code === 'zh' ? 'zh-CN' : code;
+    }
+  }, []);
+
+  const t = useCallback((key, params) => {
+    let str = getNestedValue(translations[lang], key)
+      || getNestedValue(translations[DEFAULT_LANG], key)
+      || key;
+    if (params) {
+      Object.entries(params).forEach(([k, v]) => {
+        str = str.replace(new RegExp(`\\{${k}\\}`, 'g'), v);
+      });
+    }
+    return str;
+  }, [lang]);
+
+  return (
+    <I18nContext.Provider value={{ lang, setLang, t }}>
+      {children}
+    </I18nContext.Provider>
+  );
+}
+
+export function useI18n() {
+  const ctx = useContext(I18nContext);
+  if (!ctx) throw new Error('useI18n must be used within I18nProvider');
+  return ctx;
+}
+
+export function LanguageSelector({ className = '', direction = 'up' }) {
+  const { lang, setLang } = useI18n();
+  const [open, setOpen] = useState(false);
+  const btnRef = useRef(null);
+  const [menuPos, setMenuPos] = useState({ bottom: 0, left: 0, top: 0 });
+  const current = LANGUAGES.find(l => l.code === lang) || LANGUAGES[0];
+
+  useEffect(() => {
+    if (open && btnRef.current) {
+      const rect = btnRef.current.getBoundingClientRect();
+      setMenuPos({
+        bottom: window.innerHeight - rect.top + 4,
+        left: rect.left,
+        top: rect.bottom + 4,
+      });
+    }
+  }, [open]);
+
+  const menuStyle = direction === 'down'
+    ? { top: menuPos.top, left: menuPos.left }
+    : { bottom: menuPos.bottom, left: menuPos.left };
+
+  return (
+    <div className={`relative ${className}`}>
+      <button
+        ref={btnRef}
+        onClick={() => setOpen(!open)}
+        className="flex items-center gap-1.5 px-2 py-1 rounded-lg text-xs bg-white/5 hover:bg-white/10 transition-all text-[var(--muted)] hover:text-white"
+      >
+        <span>{current.flag}</span>
+        <span>{current.label}</span>
+        <span className="text-[10px]">▾</span>
+      </button>
+      {open && (
+        <>
+          <div className="fixed inset-0 z-40" onClick={() => setOpen(false)} />
+          <div
+            className="fixed bg-[var(--card)] border border-[var(--border)] rounded-lg shadow-xl z-50 py-1 min-w-[140px]"
+            style={menuStyle}
+          >
+            {LANGUAGES.map(l => (
+              <button
+                key={l.code}
+                onClick={() => { setLang(l.code); setOpen(false); }}
+                className={`w-full text-left px-3 py-1.5 text-xs flex items-center gap-2 hover:bg-white/5 transition-all ${
+                  lang === l.code ? 'text-[var(--accent)]' : 'text-[var(--muted)]'
+                }`}
+              >
+                <span>{l.flag}</span>
+                <span>{l.label}</span>
+                {lang === l.code && <span className="ml-auto">✓</span>}
+              </button>
+            ))}
+          </div>
+        </>
+      )}
+    </div>
+  );
+}

package/src/lib/paths.js

@@ -0,0 +1,23 @@
+/**
+ * Centralized path configuration
+ * 
+ * In Electron packaged mode, data and workspace directories are set via
+ * environment variables (IDEACO_DATA_DIR / IDEACO_WORKSPACE_DIR) to point
+ * to the user's persistent userData folder, so that app updates don't
+ * overwrite user data.
+ * 
+ * In dev mode or plain `next dev`, falls back to process.cwd() based paths.
+ */
+import path from 'path';
+
+export const DATA_DIR = process.env.IDEACO_DATA_DIR
+  || path.resolve(process.cwd(), 'data');
+
+export const WORKSPACE_DIR = process.env.IDEACO_WORKSPACE_DIR
+  || path.resolve(process.cwd(), 'workspace');
+
+export const MEMORY_DIR = path.join(DATA_DIR, 'memories');
+export const CHATS_DIR = path.join(DATA_DIR, 'chats');
+export const AUDIT_DIR = path.join(DATA_DIR, 'audit');
+export const STATE_FILE = path.join(DATA_DIR, 'company-state.json');
+export const BACKUP_FILE = path.join(DATA_DIR, 'company-state.backup.json');

package/src/lib/store.js

@@ -0,0 +1,72 @@
+/**
+ * Global State Management - Server-side Singleton
+ * Shares Company instance across Next.js API Routes
+ * 
+ * Persistence:
+ * - Auto-restores from data/company-state.json on startup
+ * - Auto-saves to disk on state changes
+ * - Uses globalThis to prevent state loss during hot reload
+ */
+import { loadState, saveState, clearState } from '@/core/organization/persistence.js';
+import { Company } from '@/core/index.js';
+import { initPluginRuntime } from '@/core/system/plugin.js';
+import { sessionManager } from '@/core/agent/session.js';
+import { cronScheduler } from '@/core/system/cron.js';
+import { knowledgeManager } from '@/core/employee/knowledge.js';
+import { llmClient } from '@/core/agent/llm-agent/client.js';
+
+const globalStore = globalThis;
+
+if (!globalStore.__aiEnterprise) {
+  globalStore.__aiEnterprise = {
+    company: null,
+    loaded: false,
+  };
+
+  // Initialize plugin runtime: inject real singletons into the plugin system
+  initPluginRuntime({
+    sessionManager,
+    cronScheduler,
+    knowledgeManager,
+    llmClient,
+    messageBus: null, // messageBus is created after Company, injected lazily
+  });
+
+  // Try restoring from disk on first startup
+  try {
+    const savedData = loadState();
+    if (savedData) {
+      globalStore.__aiEnterprise.company = Company.deserialize(savedData);
+      // Inject messageBus after restoration
+      if (globalStore.__aiEnterprise.company?.messageBus) {
+        initPluginRuntime({ messageBus: globalStore.__aiEnterprise.company.messageBus });
+      }
+      console.log('🔄 Company state restored from disk successfully');
+    }
+  } catch (e) {
+    console.error('⚠️ Failed to restore state, starting with empty state:', e.message);
+    globalStore.__aiEnterprise.company = null;
+  }
+  globalStore.__aiEnterprise.loaded = true;
+}
+
+export function getCompany() {
+  return globalStore.__aiEnterprise.company;
+}
+
+export function setCompany(company) {
+  globalStore.__aiEnterprise.company = company;
+  // Inject messageBus into plugin runtime (only available after Company is created)
+  if (company && company.messageBus) {
+    initPluginRuntime({ messageBus: company.messageBus });
+  }
+  // Save to disk immediately
+  if (company) {
+    saveState(company);
+  }
+}
+
+export function resetCompany() {
+  globalStore.__aiEnterprise.company = null;
+  clearState();
+}