@aithr-ai/mcp-server 1.1.2 → 1.1.4

package/README.md

@@ -79,6 +79,41 @@ Visit [https://www.aithr.ai/settings/mcp-install](https://www.aithr.ai/settings/
 - `aether_add_file_to_folder` - Add files to folders
 - `aether_create_artifact` - Create and place artifacts
 
+## Orchestra Skill (Auto-Installed)
+
+When you install this package, it automatically installs the **Orchestra skill** to your Claude Code skills directory (`~/.claude/skills/orchestra/`).
+
+This enables the `/orchestra` command with full v6 capabilities:
+
+```bash
+/orchestra          # Start planning a new session
+/orchestra approve  # Begin autonomous execution
+/orchestra status   # Check current progress
+/orchestra push     # Push to GitHub
+```
+
+### Orchestra v6 Features
+
+- **Contract-First Development** - Define types, schemas, APIs upfront
+- **Orchestrator Brain** - AI-powered decision engine (Claude Opus 4.5)
+- **Dynamic Agent Switching** - Reassign tasks when agents struggle
+- **Structured Reports** - Consistent agent-to-orchestrator communication
+- **File Collision Prevention** - Safe parallel task execution with file locks
+- **Validation Protocol** - TypeScript checks after every code generation
+
+### Manual Skill Installation
+
+If the auto-install doesn't work, manually copy the skill:
+
+```bash
+# The skill file is bundled at:
+# node_modules/@aithr-ai/mcp-server/skills/orchestra/SKILL.md
+
+# Copy to your Claude skills directory:
+mkdir -p ~/.claude/skills/orchestra
+cp node_modules/@aithr-ai/mcp-server/skills/orchestra/SKILL.md ~/.claude/skills/orchestra/
+```
+
 ## Documentation
 
 Full documentation at [https://www.aithr.ai/docs/orchestra](https://www.aithr.ai/docs/orchestra)

package/index.js

@@ -234,12 +234,26 @@ class MCPServer {
       },
       {
         name: 'aether_list_projects',
-        description: 'List all projects in the current workspace',
+        description: 'List all projects in the current workspace. Shows which project is currently active.',
         inputSchema: {
           type: 'object',
           properties: {},
         },
       },
+      {
+        name: 'aether_switch_project',
+        description: 'Switch to a different project. All subsequent commands will use this project. Use aether_list_projects to see available projects.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            projectId: {
+              type: 'string',
+              description: 'Project ID to switch to',
+            },
+          },
+          required: ['projectId'],
+        },
+      },
       {
         name: 'aether_list_agents',
         description: 'List all agents on the current canvas',
@@ -1078,6 +1092,9 @@ class MCPServer {
         case 'aether_list_projects':
           result = await this.listProjects();
           break;
+        case 'aether_switch_project':
+          result = await this.switchProject(args);
+          break;
         case 'aether_list_agents':
           result = await this.listAgents();
           break;
@@ -1253,21 +1270,24 @@ class MCPServer {
       // Use MCP endpoint which supports API key auth
       const data = await this.mcpApiCall(`/mcp/projects/${projectId}/canvas`);
 
+      // Extract nodes and connections from the correct response structure
+      const nodes = data.canvas?.nodes || [];
+      const connections = data.canvas?.connections || [];
+
       // If summary mode, return only essential info (much smaller response)
       if (summary) {
-        const nodeSummary = (data.nodes || []).map(node => ({
+        const nodeSummary = nodes.map(node => ({
           id: node.id,
           agentId: node.agentId,
           agentType: node.agentType,
           status: node.status,
-          label: node.data?.label || node.agentId,
+          label: node.customConfig?.label || node.agentId,
         }));
 
-        const edgeSummary = (data.edges || []).map(edge => ({
-          id: edge.id,
-          source: edge.source,
-          target: edge.target,
-          type: edge.data?.connectionType,
+        const edgeSummary = connections.map(conn => ({
+          id: conn.id,
+          source: conn.sourceNodeId,
+          target: conn.targetNodeId,
         }));
 
         return {
@@ -1280,8 +1300,8 @@ class MCPServer {
 
       // Full response (can be very large)
       return {
-        nodes: data.nodes?.length || 0,
-        edges: data.edges?.length || 0,
+        nodes: nodes.length,
+        edges: connections.length,
         details: data,
       };
     } catch (e) {
@@ -1488,7 +1508,53 @@ class MCPServer {
   async listProjects() {
     try {
       const data = await this.apiCall(`/workspaces/${config.workspaceSlug}/projects`);
-      return data.map(p => ({ id: p.id, name: p.name, mode: p.mode }));
+      const projects = data.map(p => ({
+        id: p.id,
+        name: p.name,
+        mode: p.mode,
+        isActive: p.id === config.projectId,
+      }));
+      return {
+        currentProjectId: config.projectId,
+        currentProject: projects.find(p => p.isActive)?.name || 'Unknown',
+        projects,
+        hint: 'Use aether_switch_project(projectId) to switch to a different project.',
+      };
+    } catch (e) {
+      return { error: e.message };
+    }
+  }
+
+  async switchProject(args) {
+    const { projectId } = args;
+
+    if (!projectId) {
+      return { error: 'projectId is required' };
+    }
+
+    // Verify the project exists in the workspace
+    try {
+      const data = await this.apiCall(`/workspaces/${config.workspaceSlug}/projects`);
+      const project = data.find(p => p.id === projectId);
+
+      if (!project) {
+        return {
+          error: `Project ${projectId} not found in workspace`,
+          availableProjects: data.map(p => ({ id: p.id, name: p.name })),
+        };
+      }
+
+      // Update the config
+      const previousProjectId = config.projectId;
+      config.projectId = projectId;
+
+      return {
+        success: true,
+        previousProject: previousProjectId,
+        currentProject: projectId,
+        projectName: project.name,
+        message: `Switched to project "${project.name}" (${projectId}). All subsequent commands will use this project.`,
+      };
     } catch (e) {
       return { error: e.message };
     }
@@ -1503,8 +1569,8 @@ class MCPServer {
     try {
       // Use MCP endpoint which supports API key auth
       const data = await this.mcpApiCall(`/mcp/projects/${projectId}/canvas`);
-      // Canvas API returns nodes directly - they have agentId, agentType, status, customConfig
-      const nodes = data.nodes || [];
+      // Canvas API returns nodes under data.canvas.nodes
+      const nodes = data.canvas?.nodes || [];
 
       return {
         agents: nodes.map(n => ({
@@ -1666,15 +1732,18 @@ class MCPServer {
     try {
       // First get file info to get the file ID
       const filesUrl = `/workspaces/${config.workspaceSlug}/repositories/${repositoryId}/files?path=${encodeURIComponent(filePath)}`;
-      const fileInfo = await this.apiCall(filesUrl);
+      const response = await this.apiCall(filesUrl);
 
-      if (!fileInfo || fileInfo.length === 0) {
+      // API returns { files: [...], totalFiles: N }
+      const fileList = response.files || response || [];
+
+      if (!fileList || fileList.length === 0) {
         return { error: `File not found: ${filePath}` };
       }
 
-      const file = fileInfo.find(f => f.path === filePath || f.name === filePath.split('/').pop());
+      const file = fileList.find(f => f.path === filePath || f.name === filePath.split('/').pop());
       if (!file) {
-        return { error: `File not found: ${filePath}` };
+        return { error: `File not found: ${filePath}. Available files: ${fileList.slice(0, 5).map(f => f.path).join(', ')}` };
       }
 
       // Get file content
@@ -1695,16 +1764,25 @@ class MCPServer {
     const { repositoryId, query, fileTypes } = args;
 
     try {
-      let url = `/workspaces/${config.workspaceSlug}/repositories/${repositoryId}/search?q=${encodeURIComponent(query)}`;
-      if (fileTypes && fileTypes.length > 0) {
-        url += `&fileTypes=${encodeURIComponent(fileTypes.join(','))}`;
-      }
+      const url = `/workspaces/${config.workspaceSlug}/repositories/${repositoryId}/search`;
+
+      // Search API is POST, not GET
+      const data = await this.apiCall(url, {
+        method: 'POST',
+        body: JSON.stringify({
+          query,
+          mode: 'hybrid',
+          limit: 20,
+          languages: fileTypes, // Map fileTypes to languages filter
+        }),
+      });
 
-      const data = await this.apiCall(url);
       return {
         recommendation: '💡 TIP: For faster searches, clone the repo locally and use: Grep tool for content search, Glob tool for file patterns.',
         query,
-        results: data,
+        results: data.results || data,
+        totalResults: data.totalResults,
+        searchMode: data.searchMode,
       };
     } catch (e) {
       return { error: e.message };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aithr-ai/mcp-server",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "MCP server to connect Claude Code to Aether canvas - AI-powered team workspace for software development",
   "main": "index.js",
   "bin": {

package/scripts/postinstall.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+
+/**
+ * Aether MCP Server - Postinstall Script
+ *
+ * Automatically installs the Orchestra skill to the user's Claude Code skills directory.
+ * This enables the /orchestra command with full v6 capabilities.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Determine the Claude Code skills directory based on OS
+function getClaudeSkillsDir() {
+  const homeDir = os.homedir();
+
+  if (process.platform === 'win32') {
+    return path.join(homeDir, '.claude', 'skills');
+  } else if (process.platform === 'darwin') {
+    return path.join(homeDir, '.claude', 'skills');
+  } else {
+    // Linux and others
+    return path.join(homeDir, '.claude', 'skills');
+  }
+}
+
+// Source skill files (bundled with MCP package)
+const sourceSkillsDir = path.join(__dirname, '..', 'skills');
+
+// Target skills directory
+const targetSkillsDir = getClaudeSkillsDir();
+
+function copySkills() {
+  console.log('\n🎼 Aether MCP Server - Installing Orchestra Skill...\n');
+
+  // Check if source skills exist
+  if (!fs.existsSync(sourceSkillsDir)) {
+    console.log('⚠️  No skills to install (skills directory not found in package)');
+    return;
+  }
+
+  // Create target skills directory if it doesn't exist
+  if (!fs.existsSync(targetSkillsDir)) {
+    try {
+      fs.mkdirSync(targetSkillsDir, { recursive: true });
+      console.log(`📁 Created skills directory: ${targetSkillsDir}`);
+    } catch (err) {
+      console.error(`❌ Failed to create skills directory: ${err.message}`);
+      return;
+    }
+  }
+
+  // Copy each skill folder
+  const skills = fs.readdirSync(sourceSkillsDir);
+
+  for (const skillName of skills) {
+    const sourceSkillPath = path.join(sourceSkillsDir, skillName);
+    const targetSkillPath = path.join(targetSkillsDir, skillName);
+
+    // Skip if not a directory
+    if (!fs.statSync(sourceSkillPath).isDirectory()) {
+      continue;
+    }
+
+    // Create skill directory
+    if (!fs.existsSync(targetSkillPath)) {
+      fs.mkdirSync(targetSkillPath, { recursive: true });
+    }
+
+    // Copy all files in the skill directory
+    const files = fs.readdirSync(sourceSkillPath);
+
+    for (const file of files) {
+      const sourceFile = path.join(sourceSkillPath, file);
+      const targetFile = path.join(targetSkillPath, file);
+
+      // Check if target exists and is newer (don't overwrite user modifications)
+      let shouldCopy = true;
+      if (fs.existsSync(targetFile)) {
+        const sourceStats = fs.statSync(sourceFile);
+        const targetStats = fs.statSync(targetFile);
+
+        // If target is newer, ask before overwriting (in non-interactive, skip)
+        if (targetStats.mtime > sourceStats.mtime) {
+          console.log(`⏭️  Skipping ${skillName}/${file} (local version is newer)`);
+          shouldCopy = false;
+        }
+      }
+
+      if (shouldCopy) {
+        try {
+          fs.copyFileSync(sourceFile, targetFile);
+          console.log(`✅ Installed: ${skillName}/${file}`);
+        } catch (err) {
+          console.error(`❌ Failed to copy ${file}: ${err.message}`);
+        }
+      }
+    }
+  }
+
+  console.log('\n🎉 Orchestra skill installed successfully!');
+  console.log('\n📖 Usage:');
+  console.log('   /orchestra        - Start planning a new orchestra session');
+  console.log('   /orchestra approve - Begin autonomous execution');
+  console.log('   /orchestra status  - Check current progress');
+  console.log('   /orchestra push    - Push to GitHub');
+  console.log('\n💡 The skill file is located at:');
+  console.log(`   ${path.join(targetSkillsDir, 'orchestra', 'SKILL.md')}`);
+  console.log('\n');
+}
+
+// Run the installation
+try {
+  copySkills();
+} catch (err) {
+  console.error('❌ Postinstall failed:', err.message);
+  // Don't exit with error - postinstall failures shouldn't break npm install
+}