ideaco 1.1.5

package/src/core/employee/memory/store.js

@@ -0,0 +1,143 @@
+/**
+ * Independent Memory File Management Module
+ * 
+ * Each Employee's memory is stored in a separate JSON file (data/memories/{employeeId}.json),
+ * preventing all memories from being stuffed into company-state.json causing file bloat.
+ * 
+ * Workflow:
+ * 1. When saving company state, memory only serializes a summary (counts); full memory goes to separate files
+ * 2. When restoring company state, load each Employee's full memory from separate files
+ * 3. When memory changes, save only that Employee's memory file (no need to rewrite entire company state)
+ */
+import fs from 'fs';
+import path from 'path';
+import { MEMORY_DIR } from '../../../lib/paths.js';
+
+// Ensure directory exists
+if (!fs.existsSync(MEMORY_DIR)) {
+  fs.mkdirSync(MEMORY_DIR, { recursive: true });
+}
+
+/**
+ * Save a single Employee's memory to a separate file
+ * @param {string} agentId - Employee ID
+ * @param {object} memoryData - Serialized memory data { shortTerm, longTerm }
+ * @param {object} meta - Metadata { name, role, department }
+ */
+export function saveAgentMemory(agentId, memoryData, meta = {}) {
+  if (!agentId || !memoryData) return;
+  try {
+    const filePath = path.join(MEMORY_DIR, `${agentId}.json`);
+    const data = {
+      agentId,
+      name: meta.name || 'unknown',
+      role: meta.role || 'unknown',
+      department: meta.department || 'unknown',
+      shortTerm: memoryData.shortTerm || [],
+      longTerm: memoryData.longTerm || [],
+      historySummary: memoryData.historySummary || {},
+      relationships: memoryData.relationships || {},
+      savedAt: new Date().toISOString(),
+    };
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
+  } catch (e) {
+    console.error(`❌ Failed to save memory [${agentId}]:`, e.message);
+  }
+}
+
+/**
+ * Load a single Employee's memory
+ * @param {string} agentId - Employee ID
+ * @returns {object|null} { shortTerm, longTerm } or null
+ */
+export function loadAgentMemory(agentId) {
+  if (!agentId) return null;
+  try {
+    const filePath = path.join(MEMORY_DIR, `${agentId}.json`);
+    if (!fs.existsSync(filePath)) return null;
+    const json = fs.readFileSync(filePath, 'utf-8');
+    const data = JSON.parse(json);
+    return {
+      shortTerm: data.shortTerm || [],
+      longTerm: data.longTerm || [],
+      historySummary: data.historySummary || {},
+      relationships: data.relationships || {},
+    };
+  } catch (e) {
+    console.error(`❌ Failed to load memory [${agentId}]:`, e.message);
+    return null;
+  }
+}
+
+/**
+ * Batch save multiple Employees' memories
+ * @param {Array<{agentId, memoryData, meta}>} agents - Employee memory array
+ */
+export function saveAllAgentMemories(agents) {
+  let saved = 0;
+  for (const { agentId, memoryData, meta } of agents) {
+    saveAgentMemory(agentId, memoryData, meta);
+    saved++;
+  }
+  if (saved > 0) {
+    console.log(`🧠 Saved ${saved} Employee memory files`);
+  }
+}
+
+/**
+ * Delete an Employee's memory file
+ * @param {string} agentId - Employee ID
+ */
+export function deleteAgentMemory(agentId) {
+  try {
+    const filePath = path.join(MEMORY_DIR, `${agentId}.json`);
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+      console.log(`🗑️ Deleted Employee [${agentId}] memory file`);
+    }
+  } catch (e) {
+    console.error(`❌ Failed to delete memory file [${agentId}]:`, e.message);
+  }
+}
+
+/**
+ * List all saved memory files
+ * @returns {Array<{agentId, name, role, shortTermCount, longTermCount, savedAt}>}
+ */
+export function listMemoryFiles() {
+  try {
+    const files = fs.readdirSync(MEMORY_DIR).filter(f => f.endsWith('.json'));
+    return files.map(f => {
+      try {
+        const json = fs.readFileSync(path.join(MEMORY_DIR, f), 'utf-8');
+        const data = JSON.parse(json);
+        return {
+          agentId: data.agentId,
+          name: data.name,
+          role: data.role,
+          department: data.department,
+          shortTermCount: data.shortTerm?.length || 0,
+          longTermCount: data.longTerm?.length || 0,
+          savedAt: data.savedAt,
+        };
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Clear all memory files
+ */
+export function clearAllMemories() {
+  try {
+    const files = fs.readdirSync(MEMORY_DIR).filter(f => f.endsWith('.json'));
+    files.forEach(f => fs.unlinkSync(path.join(MEMORY_DIR, f)));
+    console.log(`🗑️ Cleared ${files.length} memory files`);
+  } catch (e) {
+    console.error('❌ Failed to clear memory files:', e.message);
+  }
+}

package/src/core/employee/performance.js

@@ -0,0 +1,224 @@
+import { v4 as uuidv4 } from 'uuid';
+
+/**
+ * Performance Evaluation System
+ * Supervisors evaluate employees' work results; employees provide self-feedback based on scores
+ */
+
+/** Performance scoring dimensions */
+export const PerformanceDimensions = {
+  QUALITY: 'quality',           // Work quality
+  EFFICIENCY: 'efficiency',     // Work efficiency
+  COLLABORATION: 'collaboration', // Collaboration ability
+  INNOVATION: 'innovation',     // Innovation ability
+  COMMUNICATION: 'communication', // Communication skills
+};
+
+/** Performance levels */
+export const PerformanceLevel = {
+  EXCELLENT: { label: 'Excellent', minScore: 90, emoji: '🌟' },
+  GOOD: { label: 'Good', minScore: 75, emoji: '⭐' },
+  AVERAGE: { label: 'Average', minScore: 60, emoji: '👍' },
+  BELOW_AVERAGE: { label: 'Needs Improvement', minScore: 40, emoji: '⚠️' },
+  POOR: { label: 'Poor', minScore: 0, emoji: '❌' },
+};
+
+/**
+ * Get performance level
+ */
+export function getPerformanceLevel(score) {
+  if (score >= 90) return PerformanceLevel.EXCELLENT;
+  if (score >= 75) return PerformanceLevel.GOOD;
+  if (score >= 60) return PerformanceLevel.AVERAGE;
+  if (score >= 40) return PerformanceLevel.BELOW_AVERAGE;
+  return PerformanceLevel.POOR;
+}
+
+/**
+ * Single performance review record
+ */
+export class PerformanceReview {
+  constructor({ agentId, agentName, reviewerId, reviewerName, taskTitle, scores, comment }) {
+    this.id = uuidv4();
+    this.agentId = agentId;           // Reviewee
+    this.agentName = agentName;
+    this.reviewerId = reviewerId;     // Reviewer (supervisor)
+    this.reviewerName = reviewerName;
+    this.taskTitle = taskTitle;       // Associated task
+    this.scores = scores;             // Dimension scores { quality: 85, efficiency: 90, ... }
+    this.overallScore = this._calcOverall(scores); // Overall score
+    this.level = getPerformanceLevel(this.overallScore); // Performance level
+    this.comment = comment || '';     // Supervisor's comment
+    this.selfReflection = null;       // Employee's self-feedback (filled later)
+    this.createdAt = new Date();
+  }
+
+  /** Calculate overall score (weighted average) */
+  _calcOverall(scores) {
+    const weights = {
+      [PerformanceDimensions.QUALITY]: 0.3,
+      [PerformanceDimensions.EFFICIENCY]: 0.25,
+      [PerformanceDimensions.COLLABORATION]: 0.15,
+      [PerformanceDimensions.INNOVATION]: 0.15,
+      [PerformanceDimensions.COMMUNICATION]: 0.15,
+    };
+
+    let total = 0;
+    let weightSum = 0;
+    for (const [dim, score] of Object.entries(scores)) {
+      const weight = weights[dim] || 0.2;
+      total += score * weight;
+      weightSum += weight;
+    }
+
+    return Math.round(total / (weightSum || 1));
+  }
+
+  /** Employee fills in self-feedback */
+  addSelfReflection(reflection) {
+    this.selfReflection = reflection;
+  }
+
+  /** Get summary */
+  getSummary() {
+    return {
+      id: this.id,
+      agent: this.agentName,
+      reviewer: this.reviewerName,
+      task: this.taskTitle,
+      overallScore: this.overallScore,
+      level: `${this.level.emoji} ${this.level.label}`,
+      scores: this.scores,
+      comment: this.comment,
+      selfReflection: this.selfReflection,
+    };
+  }
+}
+
+/**
+ * Performance Management System - Manages all Agent performance records
+ */
+export class PerformanceSystem {
+  constructor() {
+    this.reviews = new Map(); // agentId => PerformanceReview[]
+  }
+
+  /**
+   * Supervisor evaluates an employee
+   * @param {object} params
+   * @param {Agent} params.agent - Employee being evaluated
+   * @param {Agent} params.reviewer - Evaluator (supervisor)
+   * @param {string} params.taskTitle - Task name
+   * @param {object} params.scores - Dimension scores
+   * @param {string} [params.comment] - Comment
+   * @returns {PerformanceReview}
+   */
+  evaluate({ agent, reviewer, taskTitle, scores, comment }) {
+    const review = new PerformanceReview({
+      agentId: agent.id,
+      agentName: agent.name,
+      reviewerId: reviewer.id,
+      reviewerName: reviewer.name,
+      taskTitle,
+      scores,
+      comment,
+    });
+
+    if (!this.reviews.has(agent.id)) {
+      this.reviews.set(agent.id, []);
+    }
+    this.reviews.get(agent.id).push(review);
+
+    console.log(`  📊 Performance review: [${reviewer.name}] evaluated [${agent.name}]`);
+    console.log(`     Task: "${taskTitle}"`);
+    console.log(`     Overall score: ${review.overallScore} ${review.level.emoji} ${review.level.label}`);
+    Object.entries(scores).forEach(([dim, score]) => {
+      console.log(`     - ${dim}: ${score}`);
+    });
+    if (comment) {
+      console.log(`     Comment: "${comment}"`);
+    }
+
+    return review;
+  }
+
+  /**
+   * Simulated auto-evaluation by supervisor (generate scores based on task results)
+   */
+  autoEvaluate({ agent, reviewer, taskTitle }) {
+    // Simulated scoring: base score 60-95 random + some variance
+    const baseScore = 60 + Math.floor(Math.random() * 35);
+    const scores = {
+      [PerformanceDimensions.QUALITY]: Math.min(100, baseScore + Math.floor(Math.random() * 10 - 5)),
+      [PerformanceDimensions.EFFICIENCY]: Math.min(100, baseScore + Math.floor(Math.random() * 10 - 5)),
+      [PerformanceDimensions.COLLABORATION]: Math.min(100, baseScore + Math.floor(Math.random() * 10 - 5)),
+      [PerformanceDimensions.INNOVATION]: Math.min(100, baseScore + Math.floor(Math.random() * 10 - 5)),
+      [PerformanceDimensions.COMMUNICATION]: Math.min(100, baseScore + Math.floor(Math.random() * 10 - 5)),
+    };
+
+    const comments = {
+      90: 'Outstanding performance, exceeded expectations, a benchmark for the team!',
+      75: 'Excellent work quality, keep it up.',
+      60: 'Task completed adequately, but there is room for improvement.',
+      40: 'Performance was not ideal, improvement needed.',
+      0: 'Work output fell below standards, needs serious attention.',
+    };
+
+    const overallScore = Object.values(scores).reduce((a, b) => a + b, 0) / Object.values(scores).length;
+    let comment = comments[0];
+    for (const [threshold, c] of Object.entries(comments).sort((a, b) => b[0] - a[0])) {
+      if (overallScore >= Number(threshold)) {
+        comment = c;
+        break;
+      }
+    }
+
+    return this.evaluate({ agent, reviewer, taskTitle, scores, comment });
+  }
+
+  /**
+   * Get all performance records for an employee
+   */
+  getReviews(agentId) {
+    return this.reviews.get(agentId) || [];
+  }
+
+  /**
+   * Get an employee's average performance score
+   */
+  getAverageScore(agentId) {
+    const reviews = this.getReviews(agentId);
+    if (reviews.length === 0) return null;
+    const total = reviews.reduce((sum, r) => sum + r.overallScore, 0);
+    return Math.round(total / reviews.length);
+  }
+
+  /**
+   * Get an employee's latest review
+   */
+  getLatestReview(agentId) {
+    const reviews = this.getReviews(agentId);
+    return reviews.length > 0 ? reviews[reviews.length - 1] : null;
+  }
+
+  /**
+   * Print employee performance report
+   */
+  printReport(agentId, agentName = '') {
+    const reviews = this.getReviews(agentId);
+    const avg = this.getAverageScore(agentId);
+    const level = avg !== null ? getPerformanceLevel(avg) : null;
+
+    console.log(`\n📋 ${agentName ? `[${agentName}]` : ''} Performance Report:`);
+    console.log(`   Review count: ${reviews.length}`);
+    if (avg !== null) {
+      console.log(`   Average score: ${avg} ${level.emoji} ${level.label}`);
+    }
+    reviews.forEach((r, i) => {
+      console.log(`   #${i + 1}: "${r.taskTitle}" - ${r.overallScore} pts ${r.level.emoji}`);
+      if (r.selfReflection) {
+        console.log(`     Self-reflection: "${r.selfReflection}"`);
+      }
+    });
+  }
+}