stigmergy 1.2.13 → 1.3.1-beta

package/scripts/test-runner.js

@@ -0,0 +1,344 @@
+#!/usr/bin/env node
+
+/**
+ * Enhanced Test Runner for HookDeploymentManager Test Suite
+ * Provides comprehensive testing with reporting and analysis
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+class TestRunner {
+  constructor() {
+    this.testResults = {
+      unit: { passed: 0, failed: 0, total: 0, duration: 0 },
+      integration: { passed: 0, failed: 0, total: 0, duration: 0 },
+      regression: { passed: 0, failed: 0, total: 0, duration: 0 },
+      performance: { passed: 0, failed: 0, total: 0, duration: 0 }
+    };
+    this.startTime = Date.now();
+  }
+
+  log(message, type = 'info') {
+    const colors = {
+      info: chalk.blue,
+      success: chalk.green,
+      warning: chalk.yellow,
+      error: chalk.red
+    };
+
+    console.log(colors[type](`[${new Date().toLocaleTimeString()}] ${message}`));
+  }
+
+  async runCommand(command, description) {
+    this.log(`Running: ${description}...`);
+    const startTime = Date.now();
+
+    try {
+      const output = execSync(command, {
+        encoding: 'utf8',
+        stdio: 'pipe'
+      });
+
+      const duration = Date.now() - startTime;
+      this.log(`${description} completed successfully (${duration}ms)`, 'success');
+
+      return {
+        success: true,
+        output,
+        duration
+      };
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      this.log(`${description} failed after ${duration}ms`, 'error');
+
+      return {
+        success: false,
+        error: error.message,
+        output: error.stdout,
+        duration
+      };
+    }
+  }
+
+  parseJestOutput(output) {
+    const lines = output.split('\n');
+    const results = {
+      passed: 0,
+      failed: 0,
+      total: 0,
+      suites: 0
+    };
+
+    lines.forEach(line => {
+      const match = line.match(/Tests:\s+(\d+)\s+passed,\s+(\d+)\s+failed/);
+      if (match) {
+        results.passed = parseInt(match[1]);
+        results.failed = parseInt(match[2]);
+        results.total = results.passed + results.failed;
+      }
+
+      const suiteMatch = line.match(/Test Suites:\s+(\d+)\s+passed,\s+(\d+)\s+failed/);
+      if (suiteMatch) {
+        results.suites = parseInt(suiteMatch[1]) + parseInt(suiteMatch[2]);
+      }
+    });
+
+    return results;
+  }
+
+  async runUnitTests() {
+    this.log('\n🧪 Running Unit Tests', 'info');
+
+    const result = await this.runCommand(
+      'npm run test:unit -- --verbose --json',
+      'Unit Tests'
+    );
+
+    if (result.success) {
+      const jestOutput = result.output;
+      try {
+        const jsonMatch = jestOutput.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+          const jestResults = JSON.parse(jsonMatch[0]);
+          this.testResults.unit.passed = jestResults.numPassedTests || 0;
+          this.testResults.unit.failed = jestResults.numFailedTests || 0;
+          this.testResults.unit.total = jestResults.numTotalTests || 0;
+          this.testResults.unit.duration = jestResults.testResults?.reduce(
+            (total, test) => total + (test.duration || 0), 0
+          ) || 0;
+        } else {
+          const parsed = this.parseJestOutput(result.output);
+          Object.assign(this.testResults.unit, parsed);
+        }
+      } catch (parseError) {
+        this.log('Failed to parse Jest output, using fallback parsing', 'warning');
+        const parsed = this.parseJestOutput(result.output);
+        Object.assign(this.testResults.unit, parsed);
+      }
+    } else {
+      this.testResults.unit.failed = 1;
+    }
+
+    return result.success;
+  }
+
+  async runIntegrationTests() {
+    this.log('\n🔗 Running Integration Tests', 'info');
+
+    const result = await this.runCommand(
+      'npm run test:integration -- --verbose',
+      'Integration Tests'
+    );
+
+    if (result.success) {
+      const parsed = this.parseJestOutput(result.output);
+      Object.assign(this.testResults.integration, parsed);
+      this.testResults.integration.duration = result.duration;
+    } else {
+      this.testResults.integration.failed = 1;
+    }
+
+    return result.success;
+  }
+
+  async runRegressionTests() {
+    this.log('\n🔄 Running Regression Tests', 'info');
+
+    const result = await this.runCommand(
+      'npm run test:regression -- --verbose',
+      'Regression Tests'
+    );
+
+    if (result.success) {
+      const parsed = this.parseJestOutput(result.output);
+      Object.assign(this.testResults.regression, parsed);
+      this.testResults.regression.duration = result.duration;
+    } else {
+      this.testResults.regression.failed = 1;
+    }
+
+    return result.success;
+  }
+
+  async runPerformanceTests() {
+    this.log('\n⚡ Running Performance Tests', 'info');
+
+    const result = await this.runCommand(
+      'npm run test:performance -- --verbose',
+      'Performance Tests'
+    );
+
+    if (result.success) {
+      const parsed = this.parseJestOutput(result.output);
+      Object.assign(this.testResults.performance, parsed);
+      this.testResults.performance.duration = result.duration;
+    } else {
+      this.testResults.performance.failed = 1;
+    }
+
+    return result.success;
+  }
+
+  generateReport() {
+    const totalDuration = Date.now() - this.startTime;
+    const allTests = Object.values(this.testResults);
+    const totalPassed = allTests.reduce((sum, cat) => sum + cat.passed, 0);
+    const totalFailed = allTests.reduce((sum, cat) => sum + cat.failed, 0);
+    const totalTests = totalPassed + totalFailed;
+
+    console.log('\n' + '='.repeat(80));
+    console.log(chalk.bold.blue('📊 TEST SUITE REPORT'));
+    console.log('='.repeat(80));
+
+    // Summary
+    console.log(chalk.bold('\n📋 SUMMARY:'));
+    console.log(`Total Duration: ${(totalDuration / 1000).toFixed(2)}s`);
+    console.log(`Total Tests: ${totalTests}`);
+    console.log(`Passed: ${chalk.green(totalPassed)}`);
+    console.log(`Failed: ${chalk.red(totalFailed)}`);
+    console.log(`Success Rate: ${((totalPassed / totalTests) * 100).toFixed(1)}%`);
+
+    // Category breakdown
+    console.log(chalk.bold('\n📂 TEST CATEGORIES:'));
+
+    const categories = [
+      { name: 'Unit Tests', key: 'unit', icon: '🧪' },
+      { name: 'Integration Tests', key: 'integration', icon: '🔗' },
+      { name: 'Regression Tests', key: 'regression', icon: '🔄' },
+      { name: 'Performance Tests', key: 'performance', icon: '⚡' }
+    ];
+
+    categories.forEach(category => {
+      const results = this.testResults[category.key];
+      const success = results.failed === 0;
+      const status = success ? '✅' : '❌';
+      const color = success ? chalk.green : chalk.red;
+
+      console.log(`\n${category.icon} ${category.name}: ${status}`);
+      console.log(`  Tests: ${results.total}`);
+      console.log(`  Passed: ${color(results.passed)}`);
+      console.log(`  Failed: ${results.failed > 0 ? chalk.red(results.failed) : results.failed}`);
+      console.log(`  Duration: ${(results.duration / 1000).toFixed(2)}s`);
+    });
+
+    // Coverage information if available
+    const coveragePath = path.join(process.cwd(), 'coverage', 'coverage-summary.json');
+    if (fs.existsSync(coveragePath)) {
+      try {
+        const coverage = fs.readJsonSync(coveragePath);
+        console.log(chalk.bold('\n📈 COVERAGE SUMMARY:'));
+        console.log(`Lines: ${coverage.total.lines.pct}%`);
+        console.log(`Functions: ${coverage.total.functions.pct}%`);
+        console.log(`Branches: ${coverage.total.branches.pct}%`);
+        console.log(`Statements: ${coverage.total.statements.pct}%`);
+      } catch (error) {
+        this.log('Could not read coverage information', 'warning');
+      }
+    }
+
+    console.log('\n' + '='.repeat(80));
+
+    // Exit with appropriate code
+    const exitCode = totalFailed > 0 ? 1 : 0;
+
+    if (exitCode === 0) {
+      console.log(chalk.green.bold('\n🎉 ALL TESTS PASSED!'));
+    } else {
+      console.log(chalk.red.bold(`\n❌ ${totalFailed} TEST(S) FAILED!`));
+    }
+
+    return exitCode;
+  }
+
+  async runTestSuite() {
+    console.log(chalk.bold.blue('🚀 Starting HookDeploymentManager Test Suite'));
+    console.log(`Node.js version: ${process.version}`);
+    console.log(`Platform: ${process.platform}`);
+    console.log(`Working directory: ${process.cwd()}`);
+
+    try {
+      // Clean previous results
+      await fs.remove('coverage');
+      await fs.remove('test-results');
+
+      const unitSuccess = await this.runUnitTests();
+      const integrationSuccess = await this.runIntegrationTests();
+      const regressionSuccess = await this.runRegressionTests();
+
+      // Run performance tests only if others pass (to save time)
+      let performanceSuccess = true;
+      if (unitSuccess && integrationSuccess && regressionSuccess) {
+        performanceSuccess = await this.runPerformanceTests();
+      } else {
+        this.log('Skipping performance tests due to failures in other categories', 'warning');
+      }
+
+      // Generate report and exit
+      const exitCode = this.generateReport();
+      process.exit(exitCode);
+
+    } catch (error) {
+      this.log(`Test runner error: ${error.message}`, 'error');
+      console.error(error.stack);
+      process.exit(1);
+    }
+  }
+}
+
+// CLI interface
+if (require.main === module) {
+  const runner = new TestRunner();
+
+  // Parse command line arguments
+  const args = process.argv.slice(2);
+
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`
+HookDeploymentManager Test Runner
+
+Usage: node scripts/test-runner.js [options]
+
+Options:
+  --help, -h      Show this help message
+  --unit-only     Run only unit tests
+  --integration-only  Run only integration tests
+  --regression-only  Run only regression tests
+  --performance-only Run only performance tests
+  --no-performance Skip performance tests
+  --verbose       Enable verbose output
+
+Examples:
+  node scripts/test-runner.js                    # Run all tests
+  node scripts/test-runner.js --unit-only       # Run only unit tests
+  node scripts/test-runner.js --no-performance  # Skip performance tests
+    `);
+    process.exit(0);
+  }
+
+  // Handle specific test category requests
+  if (args.includes('--unit-only')) {
+    runner.runUnitTests().then(success => {
+      process.exit(success ? 0 : 1);
+    });
+  } else if (args.includes('--integration-only')) {
+    runner.runIntegrationTests().then(success => {
+      process.exit(success ? 0 : 1);
+    });
+  } else if (args.includes('--regression-only')) {
+    runner.runRegressionTests().then(success => {
+      process.exit(success ? 0 : 1);
+    });
+  } else if (args.includes('--performance-only')) {
+    runner.runPerformanceTests().then(success => {
+      process.exit(success ? 0 : 1);
+    });
+  } else {
+    // Run all tests
+    runner.runTestSuite();
+  }
+}
+
+module.exports = TestRunner;

package/skills/resumesession/INDEPENDENT_SKILL.md

@@ -0,0 +1,171 @@
+---
+name: resumesession
+description: Cross-CLI session recovery and history management skill
+author: stigmergy
+version: 1.0.0
+---
+
+# ResumeSession Skill
+
+Cross-CLI session recovery and history management skill for Claude CLI.
+
+## Description
+
+This skill enables Claude CLI to:
+- **Quickly recover the latest session** from all supported CLI tools
+- Compare sessions across CLIs to find the most recent one
+- Display full session content for immediate context recovery
+- Advanced mode: list sessions or show summary only
+- **Completely independent**: Does NOT depend on Stigmergy installation
+
+## Usage
+
+### Default Mode - Recover Latest Session (Recommended)
+
+To quickly recover the latest session from any CLI:
+
+```bash
+# Use independent recovery tool (no Stigmergy dependency)
+Bash("node {stigmergy_cli_path}/independent-resume.js")
+```
+
+**Important**: Since this tool is completely independent, you need to specify the path to the tool:
+- Replace `{stigmergy_cli_path}` with the actual path to `independent-resume.js`
+- For example: `C:\Users\YourName\.stigmergy\cli\independent-resume.js`
+- Or install this tool globally and use: `resume-session`
+
+This command:
+- **Compares all CLIs** (Claude, Gemini, Qwen, iFlow, CodeBuddy, Codex, QoderCLI, Kode)
+- **Finds the most recent session** across all tools
+- **Displays full session content** for immediate context recovery
+- **No intermediate steps** shown to user
+- **Silent operation** - only the recovered session is displayed
+
+### Advanced Options
+
+For more advanced usage:
+
+```bash
+# List all sessions without recovering (show available sessions)
+Bash("node {stigmergy_cli_path}/independent-resume.js --list")
+
+# Show summary only (not full content)
+Bash("node {stigmergy_cli_path}/independent-resume.js --summary")
+
+# Recover latest session from specific CLI only
+Bash("node {stigmergy_cli_path}/independent-resume.js --cli claude")
+Bash("node {stigmergy_cli_path}/independent-resume.js --cli iflow")
+```
+
+## Workflow
+
+### Standard Workflow (Default)
+
+When a user asks to recover a previous conversation (e.g., "恢复上次对话", "恢复 Claude 的上次对话"):
+
+1. **Execute recovery command**:
+   ```bash
+   Bash("node {stigmergy_cli_path}/independent-resume.js")
+   ```
+
+2. **The tool will**:
+   - Scan all CLI session directories
+   - Compare modification times across all CLIs
+   - Find the most recent session
+   - Display complete session content
+
+3. **Display result directly to the user**:
+   - Session metadata (source CLI, time, file)
+   - Full conversation content
+   - No intermediate steps or debug information
+
+4. **Continue the conversation** based on the recovered context
+
+### Advanced Workflow
+
+When a user needs to explore sessions:
+
+1. **List available sessions**:
+   ```bash
+   Bash("node {stigmergy_cli_path}/independent-resume.js --list")
+   ```
+
+2. **User selects which session to recover** based on the list
+
+3. **Recover specific CLI's latest session**:
+   ```bash
+   Bash("node {stigmergy_cli_path}/independent-resume.js --cli <cli-name>")
+   ```
+
+## Installation & Deployment
+
+This tool is designed to be **completely independent** and does not depend on Stigmergy.
+
+### Option 1: Install Globally (Recommended)
+
+```bash
+# Copy to a global location
+npm install -g https://github.com/your-repo/independent-resume
+
+# Then you can use from anywhere
+resume-session
+```
+
+### Option 2: Copy to Local Path
+
+```bash
+# Copy to your preferred location
+cp independent-resume.js ~/.local/bin/resume-session
+
+# Add to PATH in your shell config
+export PATH="$PATH:$HOME/.local/bin"
+```
+
+### Option 3: Use Relative Path from Current CLI
+
+Since the skill file is deployed to CLI tools, it can reference the relative path to `independent-resume.js`:
+
+```bash
+# Assuming skill is deployed to ~/.claude/skills/resumesession/
+Bash("node ../independent-resume.js")  # If in CLI root
+Bash("node ~/.claude/skills/resumesession/independent-resume.js")  # Full path
+```
+
+## Features
+
+- ✅ **Universal Recovery**: Finds the latest session across all CLIs automatically
+- ✅ **Smart Comparison**: Compares modification times to find the most recent session
+- ✅ **Full Content Recovery**: Displays complete session content by default
+- ✅ **Silent Operation**: No intermediate steps or debug output
+- ✅ **Cross-CLI Support**: Works with Claude, Gemini, Qwen, iFlow, CodeBuddy, Codex, QoderCLI, Kode
+- ✅ **Completely Independent**: Does NOT depend on Stigmergy installation
+- ✅ **Flexible Deployment**: Can be installed globally or used from any location
+- ✅ **Advanced Mode**: Optional listing and summary-only modes
+
+## Command Options
+
+- `--list` or `-l`: List all available sessions without recovering (advanced mode)
+- `--summary` or `-s`: Show session summary only, not full content (advanced mode)
+- `--cli <name>`: Recover latest session from a specific CLI only (advanced mode)
+
+## Supported CLIs
+
+- Claude (`.claude/projects/`)
+- Gemini (`.config/gemini/tmp/`)
+- Qwen (`.qwen/projects/`)
+- iFlow (`.iflow/projects/`)
+- CodeBuddy (`.codebuddy/`)
+- Codex (`.config/codex/`)
+- QoderCLI (`.qoder/projects/`)
+- Kode (`.kode/projects/`)
+
+## Notes
+
+**Important**: This tool is completely independent and does NOT require Stigmergy to be installed.
+
+**Default behavior**: Always recovers the latest session with full content for immediate context recovery without any user interaction or intermediate steps.
+
+**Path Resolution**: You need to provide the correct path to `independent-resume.js` in the command. This can be:
+- A global installation path
+- A local path
+- A relative path from the CLI's skill directory

package/skills/resumesession/SKILL.md

@@ -0,0 +1,127 @@
+---
+name: resumesession
+description: Cross-CLI session recovery and history management skill
+author: stigmergy
+version: 2.0.0
+---
+
+# ResumeSession Skill
+
+Cross-CLI session recovery and history management skill for all CLI tools.
+
+## Description
+
+This skill enables session recovery across all supported CLI tools with intelligent project-based filtering.
+
+## Usage
+
+### Default Behavior - Recover Current Project's Latest Session
+
+To quickly recover current project's latest session:
+
+```bash
+# Use stigmergy resume command
+stigmergy resume
+```
+
+This command:
+- **Filters by current project** (only shows sessions from current working directory)
+- **Finds most recent session** from current project
+- **Checks session content** - if latest session is empty, it recovers previous one
+- **Displays context** for immediate recovery
+
+### Show Multiple Sessions (Current Project Only)
+
+To show multiple sessions from current project:
+
+```bash
+# Show 5 most recent sessions
+stigmergy resume 5
+
+# Show 10 most recent sessions
+stigmergy resume 10
+```
+
+### Show Sessions from Specific CLI
+
+To show sessions from a specific CLI (current project only):
+
+```bash
+# Show iFlow sessions
+stigmergy resume iflow
+
+# Show 3 iFlow sessions
+stigmergy resume iflow 3
+```
+
+### Show All Projects' Sessions
+
+To show sessions from all projects:
+
+```bash
+# Show all projects' sessions (default: 10 per CLI)
+stigmergy resume --all
+
+# Show all projects' sessions with limit
+stigmergy resume --all 5
+```
+
+### Advanced Filters
+
+```bash
+# Search sessions by keyword
+stigmergy resume --search "react"
+
+# Show today's sessions
+stigmergy resume --today
+
+# Show sessions from last 7 days
+stigmergy resume --week
+
+# Show sessions from last 30 days
+stigmergy resume --month
+
+# Use different view formats
+stigmergy resume --format timeline
+stigmergy resume --format detailed
+```
+
+## Features
+
+- ✅ **Project-Aware**: Automatically filters sessions by current working directory
+- ✅ **Smart Content Check**: Skips empty sessions and finds previous one
+- ✅ **Default Context Recovery**: Shows latest session context by default
+- ✅ **Number-Based Control**: Use numbers to show multiple sessions
+- ✅ **CLI Filtering**: Filter sessions by specific CLI tool
+- ✅ **Content Search**: Search sessions by keywords
+- ✅ **Time Filtering**: Filter by date ranges (today, week, month)
+- ✅ **Multiple View Formats**: summary, timeline, detailed, context
+- ✅ **Cross-CLI Support**: Works with Claude, Gemini, Qwen, iFlow, CodeBuddy, Codex, QoderCLI, Kode
+
+## Command Behavior
+
+| Command | Behavior |
+|---------|----------|
+| `stigmergy resume` | Shows **latest session** from **current project** (context format) |
+| `stigmergy resume 5` | Shows **5 most recent sessions** from **current project** (summary format) |
+| `stigmergy resume iflow` | Shows **latest iFlow session** from **current project** |
+| `stigmergy resume iflow 5` | Shows **5 iFlow sessions** from **current project** |
+| `stigmergy resume --all` | Shows **all projects' sessions** (10 per CLI) |
+| `stigmergy resume --all 5` | Shows **all projects' sessions** (5 per CLI) |
+
+## Supported CLIs
+
+- Claude: `~/.claude/projects/{project-name}/`
+- Gemini: `~/.config/gemini/tmp/{hash}/chats/`
+- Qwen: `~/.qwen/projects/{project-name}/chats/`
+- iFlow: `~/.iflow/projects/{project-name}/`
+- CodeBuddy: `~/.codebuddy/projects/{project-name}/`
+- Codex: `~/.config/codex/`
+- QoderCLI: `~/.qoder/projects/{project-name}/`
+- Kode: `~/.kode/projects/{project-name}/`
+
+## Notes
+
+**Best Practice**: Always open your terminal in project directory before using `stigmergy resume`. This ensures you recover sessions relevant to your current project.
+
+**Important**: By default, only sessions from **current working directory** are shown. Use `--all` to see sessions from all projects.

package/skills/resumesession/__init__.py

@@ -0,0 +1,33 @@
+{
+  "name": "resumesession",
+  "displayName": "ResumeSession",
+  "version": "2.0.0",
+  "description": "Cross-CLI session recovery and history management with project-aware filtering",
+  "capabilities": [
+    "Recover latest session from current project",
+    "Check session content and skip empty sessions",
+    "Show multiple sessions from current project",
+    "Filter sessions by specific CLI",
+    "Search sessions by content keywords",
+    "Filter sessions by date range (today, week, month)",
+    "Show sessions from all projects with --all flag",
+    "Multiple view formats: summary, timeline, detailed, context",
+    "Cross-CLI support: Claude, Gemini, Qwen, iFlow, CodeBuddy, Codex, QoderCLI, Kode"
+  ],
+  "protocols": ["chinese", "english"],
+  "hooks": [],
+  "enabled": true,
+  "category": "session-management",
+  "author": "stigmergy",
+  "dependencies": [],
+  "implementations": [
+    {
+      "name": "stigmergy-resume",
+      "version": "2.0.0",
+      "language": "javascript",
+      "description": "Project-aware session recovery tool",
+      "runtime": "node",
+      "entry_point": "src/cli/commands/stigmergy-resume.js"
+    }
+  ]
+}

package/skills/resumesession/implementations/simple-resume.js

@@ -0,0 +1,13 @@
+{
+  "name": "simple-resume",
+  "version": "1.0.0",
+  "description": "Simple cross-CLI session recovery tool",
+  "language": "javascript",
+  "runtime": "node",
+  "entry_point": "src/cli/commands/simple-resume.js",
+  "metadata": {
+    "cli_type": "cross-cli",
+    "session_scope": "all",
+    "output_format": "full"
+  }
+}