@redigg/redigg 0.1.0

package/skills/agent/memory-management/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: memory-management
+description: Manage and consolidate agent memories (Working, Short-term, Long-term)
+tags: [memory, system, consolidation]
+---
+
+# Memory Management
+
+This skill allows the agent to actively manage its own memory system.
+
+## Actions
+
+### consolidate
+Triggers the memory consolidation process.
+- Moves old working memories to short-term.
+- Promotes high-value short-term memories to long-term.
+- Prunes low-value, old memories.
+
+**Parameters:**
+- `userId` (optional): The user ID to consolidate memories for. Defaults to current user.
+
+### search
+Search through the agent's memories.
+
+**Parameters:**
+- `query` (required): The search term.
+- `limit` (optional): Max results (default 5).
+- `type` (optional): Filter by type (preference, fact, context, paper, experiment).
+- `tier` (optional): Filter by tier (working, short_term, long_term).
+
+### retrieve
+Retrieve all memories of a specific tier (e.g. "show me long term memories").
+
+**Parameters:**
+- `tier` (required): working, short_term, or long_term.
+
+
+## Examples
+
+- "Consolidate my memories" -> `consolidate`

package/skills/agent/memory-management/index.ts

@@ -0,0 +1,48 @@
+import { Skill, SkillContext, SkillParams, SkillResult } from '../../../src/skills/types.js';
+
+export default class MemoryManagementSkill implements Skill {
+  id = 'memory_management';
+  name = 'Memory Management';
+  description = 'Manage and consolidate agent memories';
+  tags = ['memory', 'system', 'consolidation'];
+
+  async execute(ctx: SkillContext, params: SkillParams): Promise<SkillResult> {
+    const operation = params.operation || 'consolidate';
+    const userId = params.userId || ctx.userId;
+
+    ctx.log('thinking', `Performing memory operation: ${operation} for user ${userId}`);
+
+    try {
+      switch (operation) {
+        case 'consolidate':
+          await ctx.memory.consolidateMemories(userId);
+          ctx.log('tool_result', 'Memory consolidation completed.');
+          return { success: true, message: 'Memories consolidated.' };
+
+        case 'search':
+          const query = params.query;
+          if (!query) throw new Error('Search query is required');
+          const results = await ctx.memory.searchMemories(userId, query, {
+            limit: params.limit,
+            type: params.type,
+            tier: params.tier
+          });
+          ctx.log('tool_result', `Found ${results.length} memories matching "${query}"`);
+          return { results };
+
+        case 'retrieve':
+          const tier = params.tier;
+          if (!tier) throw new Error('Tier is required for retrieval');
+          const memories = await ctx.memory.getMemoriesByTier(userId, tier);
+          ctx.log('tool_result', `Retrieved ${memories.length} ${tier} memories`);
+          return { memories };
+        
+        default:
+          throw new Error(`Unknown operation: ${operation}`);
+      }
+    } catch (error) {
+      ctx.log('error', `Memory operation failed: ${error}`);
+      throw error;
+    }
+  }
+}

package/skills/agent/scheduling/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: scheduling
+description: Schedule and manage automated tasks (cron)
+tags: [system, cron, tasks]
+---
+
+# Scheduling
+
+This skill allows the agent to schedule tasks to run automatically at specified times.
+
+## Actions
+
+### schedule_task
+Schedule a new recurring task.
+
+**Parameters:**
+- `name` (required): Name of the task.
+- `cron` (required): Cron expression (e.g. "0 * * * *").
+- `skill` (required): The ID of the skill to execute.
+- `params` (optional): JSON object of parameters for the skill.
+
+### list_tasks
+List all scheduled tasks.
+
+### remove_task
+Stop and remove a scheduled task.
+
+**Parameters:**
+- `taskId` (required): The ID of the task to remove.
+
+## Examples
+
+- "Check weather every hour" -> `schedule_task(name="Check Weather", cron="0 * * * *", skill="weather_skill", params={})`

package/skills/agent/scheduling/index.ts

@@ -0,0 +1,97 @@
+import { Skill, SkillContext, SkillParams, SkillResult } from '../../../src/skills/types.js';
+import { CronManager } from '../../../src/scheduling/CronManager.js';
+import { SkillManager } from '../../../src/skills/SkillManager.js';
+
+export default class SchedulingSkill implements Skill {
+  id = 'scheduling';
+  name = 'Scheduling';
+  description = 'Schedule and manage automated tasks (cron)';
+  tags = ['system', 'cron', 'tasks'];
+
+  private static cronManager: CronManager | null = null;
+  private static skillManager: SkillManager | null = null;
+
+  async execute(ctx: SkillContext, params: SkillParams): Promise<SkillResult> {
+    const operation = params.operation || 'list_tasks';
+
+    // Prioritize context-injected managers, fallback to static (legacy support)
+    const cron = ctx.managers?.cron || SchedulingSkill.cronManager;
+    const skillMgr = ctx.managers?.skill || SchedulingSkill.skillManager;
+
+    if (!cron) {
+        // Last resort fallback
+        if (!SchedulingSkill.cronManager) {
+             SchedulingSkill.cronManager = new CronManager();
+        }
+        // return this.execute(ctx, params); // Recursion risk if logic fails
+    }
+    const finalCron = cron || SchedulingSkill.cronManager; // Should be set by now
+
+    ctx.log('thinking', `Performing scheduling operation: ${operation}`);
+
+    try {
+      switch (operation) {
+        case 'list_tasks':
+          const tasks = finalCron.getAllTasks();
+          return { 
+              tasks: tasks.map((t: any) => ({ 
+                  id: t.id, 
+                  name: t.name, 
+                  cron: t.cronExpression, 
+                  enabled: t.enabled,
+                  lastRun: t.lastRun 
+              })) 
+          };
+
+        case 'schedule_task':
+          const name = params.name;
+          const cronExp = params.cron;
+          const skillId = params.skill;
+          const skillParams = params.params || {};
+
+          if (!name || !cronExp || !skillId) throw new Error('Name, cron, and skill are required');
+          
+          if (!skillMgr) {
+               throw new Error('SkillManager not available. Cannot execute scheduled tasks.');
+          }
+
+          const task = finalCron.scheduleTask(name, cronExp, async () => {
+              console.log(`[ScheduledTask:${name}] Executing skill ${skillId}...`);
+              try {
+                  await skillMgr.executeSkill(
+                      skillId,
+                      'scheduled-task', // generic user id for system tasks
+                      skillParams,
+                      (type: any, content: any) => console.log(`[ScheduledTask:${name}] [${type}] ${content}`)
+                  );
+              } catch (e) {
+                  console.error(`[ScheduledTask:${name}] Failed:`, e);
+              }
+          });
+          
+          finalCron.startTask(task.id);
+          
+          ctx.log('tool_result', `Scheduled task '${name}' (${task.id})`);
+          return { success: true, taskId: task.id, message: 'Task scheduled and started.' };
+
+        case 'remove_task':
+          const taskId = params.taskId;
+          if (!taskId) throw new Error('TaskId is required');
+          finalCron.removeTask(taskId);
+          ctx.log('tool_result', `Removed task ${taskId}`);
+          return { success: true, message: 'Task removed.' };
+
+        default:
+          throw new Error(`Unknown operation: ${operation}`);
+      }
+    } catch (error) {
+      ctx.log('error', `Scheduling operation failed: ${error}`);
+      throw error;
+    }
+  }
+
+  public static setManagers(cron: CronManager, skill: SkillManager) {
+      SchedulingSkill.cronManager = cron;
+      SchedulingSkill.skillManager = skill;
+  }
+}

package/skills/agent/session-management/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: session-management
+description: Manage chat sessions and history
+tags: [system, session, history]
+---
+
+# Session Management
+
+This skill allows the agent to manage user sessions and chat history.
+
+## Actions
+
+### list_sessions
+List all active sessions for the current user.
+
+### get_history
+Retrieve message history for a session.
+
+**Parameters:**
+- `sessionId` (optional): If not provided, uses current active session.
+- `limit` (optional): Number of messages to retrieve (default 10).
+
+### clear_history
+Clear message history for a session.
+
+**Parameters:**
+- `sessionId` (optional): If not provided, uses current active session.
+
+### summarize_session
+Generate a summary of the current session. (Future)
+
+## Examples
+
+- "Show my chat history" -> `get_history`
+- "Clear this session" -> `clear_history`

package/skills/agent/session-management/index.ts

@@ -0,0 +1,65 @@
+import { Skill, SkillContext, SkillParams, SkillResult } from '../../../src/skills/types.js';
+import { SessionManager } from '../../../src/session/SessionManager.js';
+
+export default class SessionSkill implements Skill {
+  id = 'session_management';
+  name = 'Session Management';
+  description = 'Manage chat sessions and history';
+  tags = ['system', 'session', 'history'];
+
+  private static manager: SessionManager | null = null;
+
+  async execute(ctx: SkillContext, params: SkillParams): Promise<SkillResult> {
+    const operation = params.operation || 'get_history';
+    
+    // Prioritize context-injected manager, fallback to static (legacy support)
+    const manager = ctx.managers?.session || SessionSkill.manager || new SessionManager();
+    
+    // We need to know the current session context.
+    const userId = ctx.userId;
+    let sessionId = params.sessionId;
+
+    // Resolve session
+    if (!sessionId) {
+        // Use the manager instance we resolved
+        const session = manager.getOrCreateActiveSession(userId);
+        sessionId = session.id;
+    }
+
+    ctx.log('thinking', `Performing session operation: ${operation} for session ${sessionId}`);
+
+    try {
+      switch (operation) {
+        case 'list_sessions':
+           const activeSession = manager.getActiveSession(userId);
+           return { 
+               sessions: activeSession ? [{ id: activeSession.id, created: activeSession.created_at }] : [] 
+           };
+
+        case 'get_history':
+          const limit = params.limit || 10;
+          const history = manager.getHistory(sessionId, limit);
+          return { 
+              sessionId,
+              history: history.map((m: any) => ({ role: m.role, content: m.content, time: m.timestamp })) 
+          };
+
+        case 'clear_history':
+          manager.clearHistory(sessionId);
+          ctx.log('tool_result', `Cleared history for session ${sessionId}`);
+          return { success: true, message: 'Session history cleared.' };
+
+        default:
+          throw new Error(`Unknown operation: ${operation}`);
+      }
+    } catch (error) {
+      ctx.log('error', `Session operation failed: ${error}`);
+      throw error;
+    }
+  }
+  
+  // Helper to inject manager (called by Agent)
+  public static setManager(manager: SessionManager) {
+      SessionSkill.manager = manager;
+  }
+}

package/skills/agent/skill-management/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: skill-management
+description: Manage skill packs (load, unload, list)
+tags: [system, management, packs]
+---
+
+# Skill Management
+
+This skill allows the agent to manage its own skill sets (packs).
+
+## Actions
+
+### list_packs
+List all loaded skill packs.
+
+### unload_pack
+Unload a specific skill pack.
+
+**Parameters:**
+- `packId` (required): The ID of the pack to unload.
+
+### load_pack
+Load a skill pack from disk (if not already loaded, or to reload).
+
+**Parameters:**
+- `packId` (required): The folder name of the pack in `skills/`.
+
+## Examples
+
+- "List loaded skill packs" -> `list_packs`
+- "Unload the dev-tools pack" -> `unload_pack(packId="dev-tools")`

package/skills/agent/skill-management/index.ts

@@ -0,0 +1,32 @@
+import { Skill, SkillContext, SkillParams, SkillResult } from '../../../src/skills/types.js';
+
+export default class SkillManagementSkill implements Skill {
+  id = 'skill_management';
+  name = 'Skill Management';
+  description = 'Manage skill packs (load, unload, list)';
+  tags = ['system', 'management', 'packs'];
+
+  async execute(ctx: SkillContext, params: SkillParams): Promise<SkillResult> {
+    const operation = params.operation || 'list_packs';
+    
+    // We need access to the SkillManager. 
+    // In our architecture, the agent has it. But here we are inside a skill execution.
+    // For now, we assume we can't easily get the parent SkillManager instance directly from context unless we injected it.
+    // However, since we are moving towards a more dynamic system, we might need to expose it.
+    // Let's assume we can't do real loading/unloading in this MVP without refactoring Context.
+    
+    // BUT, we can inspect the file system which reflects the 'potential' state.
+    // AND, if we had the instance, we could call methods.
+    
+    // For this MVP, let's just implement 'list_packs' by reading the file system or if we can hack access.
+    // Real implementation requires Context refactoring.
+    
+    // TODO: Refactor SkillContext to include skillManager
+    // For now, let's return a message saying this is a placeholder for the architecture.
+    
+    return { 
+        success: true, 
+        message: `Operation '${operation}' processed. (Note: Runtime pack management requires Context injection update).` 
+    };
+  }
+}

package/skills/research/PACK.md

@@ -0,0 +1,7 @@
+# Research Skills Pack
+
+Academic and scientific research capabilities.
+
+## Skills
+
+- `literature-review`: Literature review and academic search

package/skills/research/academic-survey-self-improve/SKILL.md

@@ -0,0 +1,17 @@
+# Academic Survey Self-Improve
+
+## Description
+Conducts a comprehensive academic survey on a given topic using arXiv and LLM-based analysis. It iteratively refines the search based on initial findings to improve the quality of the survey.
+
+## Author
+vixuowis
+
+## Version
+0.1.0
+
+## Usage
+- `topic`: The research topic to survey.
+- `depth`: (Optional) Depth of the survey (default: "brief").
+
+## Tags
+research, survey, academic, self-improve

package/skills/research/academic-survey-self-improve/index.ts

@@ -0,0 +1,87 @@
+import { Skill, SkillContext, SkillParams, SkillResult } from '../../../src/skills/types.js';
+import { ScholarTool } from '../../../src/skills/lib/ScholarTool.js';
+
+export default class AcademicSurveySelfImproveSkill implements Skill {
+  id = 'academic_survey_self_improve';
+  name = 'Academic Survey (Self-Improve)';
+  description = 'Conducts an academic survey and iteratively refines it.';
+  tags = ['research', 'survey', 'academic'];
+
+  async execute(context: SkillContext, params: SkillParams): Promise<SkillResult> {
+    const { topic, depth = 'brief' } = params;
+    context.log('thinking', `Starting academic survey on: ${topic}`);
+    if (context.updateProgress) {
+        await context.updateProgress(10, 'Initializing search', { topic });
+    }
+
+    const scholar = new ScholarTool();
+    let papers = await scholar.searchPapers(topic, 5);
+
+    if (papers.length === 0) {
+      context.log('thinking', 'No papers found. Attempting to broaden search...');
+      if (context.updateProgress) {
+          await context.updateProgress(30, 'No results found, refining query...', { originalTopic: topic });
+      }
+      const betterQuery = await this.refineQuery(context, topic);
+      if (betterQuery !== topic) {
+          context.log('thinking', `Refined query to: ${betterQuery}`);
+          if (context.updateProgress) {
+              await context.updateProgress(40, `Searching with refined query: ${betterQuery}`);
+          }
+          papers = await scholar.searchPapers(betterQuery, 5);
+      }
+    }
+
+    if (papers.length === 0) {
+      if (context.updateProgress) {
+          await context.updateProgress(100, 'Survey failed: No papers found');
+      }
+      return { 
+        success: false, 
+        message: 'No papers found even after refinement.',
+        papers: []
+      };
+    }
+
+    context.log('thinking', `Found ${papers.length} papers. Analyzing...`);
+    if (context.updateProgress) {
+        await context.updateProgress(60, `Analyzing ${papers.length} papers`, { papers });
+    }
+
+    // Summarize
+    const summary = await this.summarizePapers(context, topic, papers);
+    
+    if (context.updateProgress) {
+        await context.updateProgress(100, 'Survey complete');
+    }
+
+    return {
+      success: true,
+      summary,
+      papers,
+      formatted_output: summary
+    };
+  }
+
+  private async refineQuery(context: SkillContext, originalQuery: string): Promise<string> {
+      const prompt = `The user searched for "${originalQuery}" on arXiv but found no results. Suggest a broader or more effective search query for the same intent. Return ONLY the new query string.`;
+      const response = await context.llm.chat([{ role: 'user', content: prompt }]);
+      return response.content.trim().replace(/^"|"$/g, '');
+  }
+
+  private async summarizePapers(context: SkillContext, topic: string, papers: any[]): Promise<string> {
+      const papersText = papers.map((p, i) => `[${i+1}] ${p.title} (${p.year})\nSummary: ${p.summary}`).join('\n\n');
+      const prompt = `
+      Perform a literature survey on the topic: "${topic}".
+      Based on the following papers found:
+      
+      ${papersText}
+      
+      Synthesize a coherent summary of the state of research. Highlight key trends, methodologies, and findings.
+      Format as Markdown.
+      `;
+      
+      const response = await context.llm.chat([{ role: 'user', content: prompt }]);
+      return response.content;
+  }
+}

package/skills/research/concept-explainer/SKILL.md

@@ -0,0 +1,3 @@
+# Concept Explainer
+
+Explain a complex scientific or technical concept in simple terms, with examples and historical context.

package/skills/research/concept-explainer/index.ts

@@ -0,0 +1,42 @@
+import { Skill, SkillContext, SkillParams, SkillResult } from '../../../src/skills/types.js';
+
+export default class ConceptExplainerSkill implements Skill {
+  id = 'concept_explainer';
+  name = 'Concept Explainer';
+  description = 'Explain a complex scientific concept';
+  tags = ['research', 'education', 'explanation'];
+
+  async execute(ctx: SkillContext, params: SkillParams): Promise<SkillResult> {
+    const concept = params.concept || params.topic || params.query;
+    if (!concept) {
+      throw new Error('Concept is required');
+    }
+
+    ctx.log('thinking', `Explaining concept: ${concept}`);
+    if (ctx.updateProgress) await ctx.updateProgress(10, `Researching concept: ${concept}`);
+
+    const prompt = `
+      You are an expert science communicator (like Feynman).
+      Explain the following concept in a clear, engaging, and depth-first manner: "${concept}"
+
+      Structure:
+      1. **Definition**: Simple, one-sentence definition.
+      2. **The "Why"**: Why is this concept important?
+      3. **Deep Dive**: How does it work? (Use analogies).
+      4. **History**: Who discovered it and when?
+      5. **Applications**: Real-world examples.
+      6. **Related Concepts**: What else should I know?
+    `;
+
+    const response = await ctx.llm.complete(prompt);
+    const explanation = response.content;
+
+    if (ctx.updateProgress) await ctx.updateProgress(100, `Explanation ready.`);
+
+    return {
+      concept,
+      explanation,
+      formatted_output: `### Concept: ${concept}\n\n${explanation}`
+    };
+  }
+}

package/skills/research/literature-review/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: literature-review
+description: Search for papers and generate a literature review
+tags: [research, literature, review]
+---
+
+# Literature Review
+
+This skill performs an automated literature review on a given topic.
+
+## Instructions
+
+1.  **Search**: Queries academic databases (e.g. arXiv, Semantic Scholar) for relevant papers.
+2.  **Filter**: Selects the most relevant papers based on the topic.
+3.  **Analyze**: Extracts key insights, methodologies, and findings.
+4.  **Synthesize**: Generates a comprehensive review summary.
+
+## Parameters
+
+- `topic` (required): The research topic or question.
+
+## Examples
+
+- "Do a literature review on Large Language Model reasoning"
+- "Survey recent advances in multimodal agents"