stigmergy 1.2.8 → 1.2.11

package/src/core/skills/test-runner.js

@@ -0,0 +1,242 @@
+/**
+ * Simple Test Runner - TDD Verification
+ * No dependency on Jest, runs tests directly
+ */
+
+import { SkillParser } from './embedded-openskills/SkillParser.js';
+import { SkillReader } from './embedded-openskills/SkillReader.js';
+import { SkillInstaller } from './embedded-openskills/SkillInstaller.js';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import assert from 'assert';
+
+class TestRunner {
+    constructor() {
+        this.passed = 0;
+        this.failed = 0;
+        this.tests = [];
+    }
+
+    async test(name, fn) {
+        try {
+            await fn();
+            this.passed++;
+            console.log(`[OK] ${name}`);
+        } catch (err) {
+            this.failed++;
+            console.error(`[X] ${name}`);
+            console.error(`   Error: ${err.message}`);
+            if (err.stack) {
+                console.error(`   ${err.stack.split('\n')[1]}`);
+            }
+        }
+    }
+
+    summary() {
+        console.log(`\n${'='.repeat(60)}`);
+        console.log(`Total: ${this.passed + this.failed} tests`);
+        console.log(`[OK] Passed: ${this.passed}`);
+        console.log(`[X] Failed: ${this.failed}`);
+        console.log('='.repeat(60));
+        return this.failed === 0;
+    }
+}
+
+async function runTests() {
+    const runner = new TestRunner();
+    let tempDir;
+
+    console.log('[LIST] Running TDD tests...\n');
+
+    // ===== SkillParser Tests =====
+    console.log('[LIST] SkillParser Tests\n');
+
+    await runner.test('parseMetadata - Parse valid YAML', () => {
+        const parser = new SkillParser();
+        const content = `---
+name: test-skill
+description: A test skill
+version: 1.0.0
+---
+
+# Content`;
+        const result = parser.parseMetadata(content);
+        assert.strictEqual(result.name, 'test-skill');
+        assert.strictEqual(result.description, 'A test skill');
+    });
+
+    await runner.test('parseMetadata - Handle arrays', () => {
+        const parser = new SkillParser();
+        const content = `---
+name: skill
+allowed-tools:
+  - bash
+  - text_editor
+---`;
+        const result = parser.parseMetadata(content);
+        assert.deepStrictEqual(result['allowed-tools'], ['bash', 'text_editor']);
+    });
+
+    await runner.test('extractContent - Extract body content', () => {
+        const parser = new SkillParser();
+        const content = `---
+name: test
+---
+
+# Instructions`;
+        const result = parser.extractContent(content);
+        assert(result.includes('# Instructions'));
+        assert(!result.includes('---'));
+    });
+
+    await runner.test('validateSkill - Detect missing name', () => {
+        const parser = new SkillParser();
+        const content = `---
+description: No name
+---`;
+        const result = parser.validateSkill(content);
+        assert.strictEqual(result.valid, false);
+        assert(result.errors.some(e => e.includes('name')));
+    });
+
+    await runner.test('validateSkill - Detect invalid name format', () => {
+        const parser = new SkillParser();
+        const content = `---
+name: Invalid_Name
+description: Test
+---`;
+        const result = parser.validateSkill(content);
+        assert.strictEqual(result.valid, false);
+        assert(result.errors.some(e => e.includes('lowercase and hyphens')));
+    });
+
+    // ===== SkillReader Tests =====
+    console.log('\n[LIST] SkillReader Tests\n');
+
+    // Setup test environment
+    tempDir = path.join(os.tmpdir(), `test-skills-${Date.now()}`);
+    await fs.mkdir(tempDir, { recursive: true });
+
+    await runner.test('findSkill - Find existing skill', async () => {
+        const skillName = 'test-skill';
+        const skillDir = path.join(tempDir, skillName);
+        await fs.mkdir(skillDir, { recursive: true });
+        await fs.writeFile(
+            path.join(skillDir, 'SKILL.md'),
+            '---\nname: test-skill\n---\n# Test'
+        );
+
+        const reader = new SkillReader([tempDir]);
+        const result = await reader.findSkill(skillName);
+        
+        assert.notStrictEqual(result, null);
+        assert.strictEqual(result.name, skillName);
+    });
+
+    await runner.test('findSkill - Non-existent skill returns null', async () => {
+        const reader = new SkillReader([tempDir]);
+        const result = await reader.findSkill('non-existent');
+        assert.strictEqual(result, null);
+    });
+
+    await runner.test('readSkill - Read skill content', async () => {
+        const skillName = 'readable-skill';
+        const skillDir = path.join(tempDir, skillName);
+        await fs.mkdir(skillDir);
+        const content = '---\nname: readable-skill\n---\n# Content';
+        await fs.writeFile(path.join(skillDir, 'SKILL.md'), content);
+
+        const reader = new SkillReader([tempDir]);
+        const result = await reader.readSkill(skillName);
+        
+        assert.strictEqual(result.name, skillName);
+        assert.strictEqual(result.content, content);
+    });
+
+    await runner.test('listSkills - List all skills', async () => {
+        const skills = ['skill-1', 'skill-2'];
+        for (const name of skills) {
+            const dir = path.join(tempDir, name);
+            await fs.mkdir(dir);
+            await fs.writeFile(
+                path.join(dir, 'SKILL.md'),
+                `---\nname: ${name}\ndescription: ${name}\n---\n`
+            );
+        }
+
+        const reader = new SkillReader([tempDir]);
+        const result = await reader.listSkills();
+        
+        assert(result.length >= skills.length);
+        const names = result.map(s => s.name);
+        skills.forEach(name => assert(names.includes(name)));
+    });
+
+    // ===== SkillInstaller Tests =====
+    console.log('\n[LIST] SkillInstaller Tests\n');
+
+    await runner.test('parseGitHubUrl - Parse standard URL', () => {
+        const installer = new SkillInstaller();
+        const result = installer.parseGitHubUrl('https://github.com/owner/repo');
+        assert.strictEqual(result.owner, 'owner');
+        assert.strictEqual(result.repo, 'repo');
+    });
+
+    await runner.test('parseGitHubUrl - Parse shorthand format', () => {
+        const installer = new SkillInstaller();
+        const result = installer.parseGitHubUrl('owner/repo');
+        assert.strictEqual(result.owner, 'owner');
+        assert.strictEqual(result.repo, 'repo');
+    });
+
+    await runner.test('parseGitHubUrl - Remove .git suffix', () => {
+        const installer = new SkillInstaller();
+        const result = installer.parseGitHubUrl('owner/repo.git');
+        assert.strictEqual(result.repo, 'repo');
+    });
+
+    await runner.test('scanSkills - Scan skill directory', async () => {
+        const scanDir = path.join(tempDir, 'scan-test');
+        await fs.mkdir(scanDir);
+        
+        const skill1 = path.join(scanDir, 'skill-a');
+        await fs.mkdir(skill1);
+        await fs.writeFile(
+            path.join(skill1, 'SKILL.md'),
+            '---\nname: skill-a\n---\n'
+        );
+
+        const installer = new SkillInstaller();
+        const skills = await installer.scanSkills(scanDir);
+        
+        assert(skills.length >= 1);
+        assert(skills.some(s => s.name === 'skill-a'));
+    });
+
+    await runner.test('calculateSize - Calculate directory size', async () => {
+        const sizeDir = path.join(tempDir, 'size-test');
+        await fs.mkdir(sizeDir);
+        await fs.writeFile(path.join(sizeDir, 'file.txt'), 'x'.repeat(100));
+
+        const installer = new SkillInstaller();
+        const size = await installer.calculateSize(sizeDir);
+        
+        assert.strictEqual(size, 100);
+    });
+
+    // Cleanup
+    await fs.rm(tempDir, { recursive: true, force: true });
+
+    return runner.summary();
+}
+
+// Run tests
+runTests()
+    .then(success => {
+        process.exit(success ? 0 : 1);
+    })
+    .catch(err => {
+        console.error('[X] Test execution failed:', err);
+        process.exit(1);
+    });

package/src/utils/helpers.js

@@ -1,32 +1,15 @@
 const fs = require('fs/promises');
 const fsSync = require('fs');
 const path = require('path');
-const { UserAuthenticator } = require('../auth');
 
 function maxOfTwo(a, b) {
   return a > b ? a : b;
 }
 
+// Placeholder function - always returns true since no user authentication is needed
+// for a multi-AI CLI collaboration system
 function isAuthenticated() {
-  try {
-    const authenticator = new UserAuthenticator();
-    // Load authentication data
-    const authFile = path.join(
-      process.env.HOME || process.env.USERPROFILE,
-      '.stigmergy',
-      'auth.json',
-    );
-
-    if (!fsSync.existsSync(authFile)) {
-      return false;
-    }
-
-    const authData = JSON.parse(fsSync.readFileSync(authFile, 'utf8'));
-    return authenticator.validateToken(authData.token);
-  } catch (error) {
-    console.log(`[AUTH] Authentication check failed: ${error.message}`);
-    return false;
-  }
+  return true;
 }
 
 module.exports = {

package/src/auth.js

@@ -1,173 +0,0 @@
-/**
- * Authentication module for the Stigmergy CLI system.
- * Provides user authentication functionality including password hashing and token management.
- */
-
-const crypto = require('crypto');
-
-/**
- * Custom exception for authentication failures.
- */
-class AuthenticationError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'AuthenticationError';
-  }
-}
-
-/**
- * Handles user authentication operations including registration, login, and session management.
- */
-class UserAuthenticator {
-  /**
-   * Create a new UserAuthenticator instance.
-   */
-  constructor() {
-    // In production, this would be stored in a secure database
-    this._users = new Map();
-    this._sessions = new Map();
-  }
-
-  /**
-   * Register a new user with the provided username and password.
-   *
-   * @param {string} username - The user's username
-   * @param {string} password - The user's password
-   * @returns {boolean} True if registration successful, false if username already exists
-   * @throws {Error} If username or password is invalid
-   */
-  registerUser(username, password) {
-    if (!username || !password) {
-      throw new Error('Username and password cannot be empty');
-    }
-
-    if (username.length < 3) {
-      throw new Error('Username must be at least 3 characters long');
-    }
-
-    if (password.length < 8) {
-      throw new Error('Password must be at least 8 characters long');
-    }
-
-    if (this._users.has(username)) {
-      return false;
-    }
-
-    // Hash the password with a salt
-    const salt = crypto.randomBytes(16).toString('hex');
-    const passwordHash = this._hashPassword(password, salt);
-
-    this._users.set(username, {
-      passwordHash: passwordHash,
-      salt: salt,
-    });
-
-    return true;
-  }
-
-  /**
-   * Authenticate a user with the provided credentials.
-   *
-   * @param {string} username - The user's username
-   * @param {string} password - The user's password
-   * @returns {string} Session token if authentication is successful
-   * @throws {AuthenticationError} If authentication fails
-   */
-  authenticateUser(username, password) {
-    if (!this._users.has(username)) {
-      throw new AuthenticationError('Invalid username or password');
-    }
-
-    const userData = this._users.get(username);
-    const passwordHash = this._hashPassword(password, userData.salt);
-
-    if (passwordHash !== userData.passwordHash) {
-      throw new AuthenticationError('Invalid username or password');
-    }
-
-    // Generate session token
-    const sessionToken = crypto.randomBytes(32).toString('base64url');
-    this._sessions.set(sessionToken, {
-      username: username,
-      createdAt: Date.now(),
-    });
-
-    return sessionToken;
-  }
-
-  /**
-   * Validate a session token and return the associated username.
-   *
-   * @param {string} sessionToken - The session token to validate
-   * @returns {string|null} Username if session is valid, null otherwise
-   */
-  validateSession(sessionToken) {
-    if (!this._sessions.has(sessionToken)) {
-      return null;
-    }
-
-    // In production, you would check session expiration here
-    return this._sessions.get(sessionToken).username;
-  }
-
-  /**
-   * Invalidate a session token.
-   *
-   * @param {string} sessionToken - The session token to invalidate
-   * @returns {boolean} True if session was invalidated, false if token was not found
-   */
-  logout(sessionToken) {
-    if (this._sessions.has(sessionToken)) {
-      this._sessions.delete(sessionToken);
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * Hash a password with the provided salt using PBKDF2.
-   *
-   * @param {string} password - The password to hash
-   * @param {string} salt - The salt to use for hashing
-   * @returns {string} The hashed password
-   * @private
-   */
-  _hashPassword(password, salt) {
-    return crypto
-      .pbkdf2Sync(
-        password,
-        salt,
-        100000, // iterations
-        32, // key length
-        'sha256', // digest
-      )
-      .toString('hex');
-  }
-}
-
-/**
- * Helper function to authenticate a user and return a session token.
- *
- * @param {UserAuthenticator} authenticator - The authenticator instance
- * @param {string} username - The user's username
- * @param {string} password - The user's password
- * @returns {[boolean, string]} A tuple containing success status and message/token
- */
-function authenticateAndGetToken(authenticator, username, password) {
-  try {
-    const token = authenticator.authenticateUser(username, password);
-    return [true, token];
-  } catch (error) {
-    if (error instanceof AuthenticationError) {
-      return [false, error.message];
-    } else {
-      return [false, `Authentication error: ${error.message}`];
-    }
-  }
-}
-
-module.exports = {
-  UserAuthenticator,
-  AuthenticationError,
-  authenticateAndGetToken,
-};

package/src/auth_command.js

@@ -1,208 +0,0 @@
-/**
- * Authentication command handler for the Stigmergy CLI.
- * Provides CLI commands for user registration, login, and session management.
- */
-
-const fs = require('fs');
-const path = require('path');
-const { UserAuthenticator, authenticateAndGetToken } = require('./auth');
-
-/**
- * Get the path to the authentication data file.
- * @returns {string} Path to the auth data file
- */
-function getAuthDataPath() {
-  const homeDir = process.env.HOME || process.env.USERPROFILE;
-  const configDir = path.join(homeDir, '.stigmergy');
-
-  // Create config directory if it doesn't exist
-  if (!fs.existsSync(configDir)) {
-    fs.mkdirSync(configDir, { recursive: true });
-  }
-
-  return path.join(configDir, 'auth.json');
-}
-
-/**
- * Load authentication data from file.
- * @param {UserAuthenticator} authenticator - The authenticator instance
- */
-function loadAuthData(authenticator) {
-  try {
-    const authFile = getAuthDataPath();
-    if (fs.existsSync(authFile)) {
-      const data = JSON.parse(fs.readFileSync(authFile, 'utf8'));
-
-      // Load users
-      if (data.users) {
-        for (const [username, userData] of Object.entries(data.users)) {
-          authenticator._users.set(username, userData);
-        }
-      }
-
-      // Load sessions
-      if (data.sessions) {
-        for (const [token, sessionData] of Object.entries(data.sessions)) {
-          authenticator._sessions.set(token, sessionData);
-        }
-      }
-    }
-  } catch (error) {
-    console.warn('[WARN] Could not load authentication data:', error.message);
-  }
-}
-
-/**
- * Save authentication data to file.
- * @param {UserAuthenticator} authenticator - The authenticator instance
- */
-function saveAuthData(authenticator) {
-  try {
-    const authFile = getAuthDataPath();
-
-    // Convert Maps to objects for JSON serialization
-    const users = {};
-    for (const [username, userData] of authenticator._users.entries()) {
-      users[username] = userData;
-    }
-
-    const sessions = {};
-    for (const [token, sessionData] of authenticator._sessions.entries()) {
-      sessions[token] = sessionData;
-    }
-
-    const data = {
-      users,
-      sessions,
-    };
-
-    fs.writeFileSync(authFile, JSON.stringify(data, null, 2));
-  } catch (error) {
-    console.warn('[WARN] Could not save authentication data:', error.message);
-  }
-}
-
-/**
- * Handle user registration.
- * @param {string} username - The username to register
- * @param {string} password - The password for the user
- */
-function handleRegister(username, password) {
-  const authenticator = new UserAuthenticator();
-  loadAuthData(authenticator);
-
-  try {
-    const success = authenticator.registerUser(username, password);
-    if (success) {
-      saveAuthData(authenticator);
-      console.log(`[SUCCESS] User '${username}' registered successfully`);
-    } else {
-      console.log(`[ERROR] Username '${username}' already exists`);
-      process.exit(1);
-    }
-  } catch (error) {
-    console.log(`[ERROR] Registration failed: ${error.message}`);
-    process.exit(1);
-  }
-}
-
-/**
- * Handle user login.
- * @param {string} username - The username to login
- * @param {string} password - The password for the user
- */
-function handleLogin(username, password) {
-  const authenticator = new UserAuthenticator();
-  loadAuthData(authenticator);
-
-  const [success, result] = authenticateAndGetToken(
-    authenticator,
-    username,
-    password,
-  );
-
-  if (success) {
-    const token = result;
-    saveAuthData(authenticator);
-
-    // Also save the token to a session file for easy access
-    const sessionFile = path.join(
-      path.dirname(getAuthDataPath()),
-      'session.token',
-    );
-    fs.writeFileSync(sessionFile, token);
-
-    console.log('[SUCCESS] Login successful');
-    console.log(`Session token: ${token}`);
-  } else {
-    console.log(`[ERROR] Login failed: ${result}`);
-    process.exit(1);
-  }
-}
-
-/**
- * Handle user logout.
- */
-function handleLogout() {
-  const authenticator = new UserAuthenticator();
-  loadAuthData(authenticator);
-
-  // Read the current session token
-  const sessionFile = path.join(
-    path.dirname(getAuthDataPath()),
-    'session.token',
-  );
-
-  if (!fs.existsSync(sessionFile)) {
-    console.log('[ERROR] No active session found');
-    process.exit(1);
-  }
-
-  const token = fs.readFileSync(sessionFile, 'utf8').trim();
-
-  const success = authenticator.logout(token);
-  if (success) {
-    saveAuthData(authenticator);
-    fs.unlinkSync(sessionFile); // Remove the session file
-    console.log('[SUCCESS] Logged out successfully');
-  } else {
-    console.log('[ERROR] Logout failed: Invalid session');
-    process.exit(1);
-  }
-}
-
-/**
- * Check if user is authenticated.
- */
-function handleStatus() {
-  const authenticator = new UserAuthenticator();
-  loadAuthData(authenticator);
-
-  // Read the current session token
-  const sessionFile = path.join(
-    path.dirname(getAuthDataPath()),
-    'session.token',
-  );
-
-  if (!fs.existsSync(sessionFile)) {
-    console.log('[INFO] No active session');
-    return;
-  }
-
-  const token = fs.readFileSync(sessionFile, 'utf8').trim();
-  const username = authenticator.validateSession(token);
-
-  if (username) {
-    console.log(`[INFO] Authenticated as: ${username}`);
-  } else {
-    console.log('[INFO] Session expired or invalid');
-    fs.unlinkSync(sessionFile); // Remove the invalid session file
-  }
-}
-
-module.exports = {
-  handleRegister,
-  handleLogin,
-  handleLogout,
-  handleStatus,
-};