makecc 0.1.0

package/server/services/claudeService.ts

@@ -0,0 +1,222 @@
+import Anthropic from '@anthropic-ai/sdk';
+import type {
+  ExecutionNode,
+  SubagentNodeData,
+  SkillNodeData,
+  InputNodeData,
+  OutputNodeData,
+  McpNodeData,
+} from '../types';
+
+type ModelId = 'claude-sonnet-4-20250514' | 'claude-opus-4-20250514' | 'claude-3-5-haiku-20241022';
+
+export class ClaudeService {
+  private client: Anthropic;
+  private abortController: AbortController | null = null;
+  private executionResults: Map<string, string> = new Map();
+
+  constructor() {
+    this.client = new Anthropic();
+  }
+
+  private getModelId(model?: 'sonnet' | 'opus' | 'haiku'): ModelId {
+    switch (model) {
+      case 'opus':
+        return 'claude-opus-4-20250514';
+      case 'haiku':
+        return 'claude-3-5-haiku-20241022';
+      default:
+        return 'claude-sonnet-4-20250514';
+    }
+  }
+
+  async executeNode(
+    node: ExecutionNode,
+    onProgress?: (progress: number) => void
+  ): Promise<string> {
+    this.abortController = new AbortController();
+
+    switch (node.type) {
+      case 'input':
+        return this.executeInputNode(node.id, node.data as InputNodeData);
+
+      case 'subagent':
+        return this.executeSubagentNode(
+          node.id,
+          node.data as SubagentNodeData,
+          onProgress
+        );
+
+      case 'skill':
+        return this.executeSkillNode(node.id, node.data as SkillNodeData);
+
+      case 'mcp':
+        return this.executeMcpNode(node.id, node.data as McpNodeData);
+
+      case 'output':
+        return this.executeOutputNode(node.id, node.data as OutputNodeData);
+
+      default:
+        throw new Error(`Unknown node type: ${node.type}`);
+    }
+  }
+
+  private async executeInputNode(
+    nodeId: string,
+    data: InputNodeData
+  ): Promise<string> {
+    const result = data.value || '';
+    this.executionResults.set(nodeId, result);
+    return result;
+  }
+
+  private async executeSubagentNode(
+    nodeId: string,
+    data: SubagentNodeData,
+    onProgress?: (progress: number) => void
+  ): Promise<string> {
+    onProgress?.(10);
+
+    // Build context from used inputs
+    let context = '';
+    if (data.usedInputs && data.usedInputs.length > 0) {
+      const inputs = data.usedInputs
+        .map((inputId) => this.executionResults.get(inputId))
+        .filter(Boolean)
+        .join('\n\n');
+      context = `Context from previous steps:\n${inputs}\n\n`;
+    }
+
+    // Build system prompt based on role
+    let systemPrompt = data.systemPrompt || this.getDefaultSystemPrompt(data.role);
+
+    // Add tool instructions if tools are specified
+    if (data.tools && data.tools.length > 0) {
+      systemPrompt += `\n\nYou have access to the following tools: ${data.tools.join(', ')}`;
+    }
+
+    onProgress?.(30);
+
+    try {
+      const response = await this.client.messages.create({
+        model: this.getModelId(data.model),
+        max_tokens: 4096,
+        system: systemPrompt,
+        messages: [
+          {
+            role: 'user',
+            content: `${context}${data.description || 'Please complete the assigned task.'}`,
+          },
+        ],
+      });
+
+      onProgress?.(80);
+
+      // Extract text from response
+      const result = response.content
+        .filter((block) => block.type === 'text')
+        .map((block) => (block as { type: 'text'; text: string }).text)
+        .join('\n');
+
+      this.executionResults.set(nodeId, result);
+      onProgress?.(100);
+
+      return result;
+    } catch (error) {
+      throw new Error(`Claude API error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  private async executeSkillNode(
+    nodeId: string,
+    data: SkillNodeData
+  ): Promise<string> {
+    // Build context from used inputs
+    let context = '';
+    if (data.usedInputs && data.usedInputs.length > 0) {
+      const inputs = data.usedInputs
+        .map((inputId) => this.executionResults.get(inputId))
+        .filter(Boolean)
+        .join('\n\n');
+      context = inputs;
+    }
+
+    // For now, return the skill configuration as result
+    // In a full implementation, this would execute the skill's SKILL.md
+    const result = data.mdContent
+      ? `Skill executed with content:\n${data.mdContent}\n\nContext: ${context}`
+      : `Skill ${data.skillId || 'custom'} executed with context: ${context}`;
+
+    this.executionResults.set(nodeId, result);
+    return result;
+  }
+
+  private async executeMcpNode(
+    nodeId: string,
+    data: McpNodeData
+  ): Promise<string> {
+    // MCP server integration would go here
+    // For now, return a placeholder result
+    const result = `MCP Server ${data.serverName} (${data.serverType}) connection established`;
+    this.executionResults.set(nodeId, result);
+    return result;
+  }
+
+  private async executeOutputNode(
+    nodeId: string,
+    data: OutputNodeData
+  ): Promise<string> {
+    // Collect all results from used inputs
+    let combinedResult = '';
+    if (data.usedInputs && data.usedInputs.length > 0) {
+      const inputs = data.usedInputs
+        .map((inputId) => this.executionResults.get(inputId))
+        .filter(Boolean);
+      combinedResult = inputs.join('\n\n---\n\n');
+    }
+
+    // Format based on output type
+    let formattedResult: string;
+    switch (data.outputType) {
+      case 'markdown':
+        formattedResult = combinedResult;
+        break;
+      case 'document':
+        formattedResult = `# Document Output\n\n${combinedResult}`;
+        break;
+      default:
+        formattedResult = combinedResult;
+    }
+
+    this.executionResults.set(nodeId, formattedResult);
+    return formattedResult;
+  }
+
+  private getDefaultSystemPrompt(role: string): string {
+    const prompts: Record<string, string> = {
+      researcher:
+        'You are an expert researcher. Your task is to gather, analyze, and synthesize information on the given topic. Provide comprehensive, well-structured findings with citations where applicable.',
+      writer:
+        'You are a professional writer. Your task is to create clear, engaging, and well-structured content. Focus on readability and appropriate tone for the target audience.',
+      analyst:
+        'You are a data analyst. Your task is to analyze information, identify patterns, and provide insights. Present your findings in a clear, actionable format.',
+      coder:
+        'You are an expert software developer. Your task is to write clean, efficient, and well-documented code. Follow best practices and consider edge cases.',
+      custom:
+        'You are a helpful AI assistant. Complete the assigned task to the best of your ability.',
+    };
+
+    return prompts[role] || prompts.custom;
+  }
+
+  cancelExecution(): void {
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+  }
+
+  clearResults(): void {
+    this.executionResults.clear();
+  }
+}

package/server/services/fileService.ts

@@ -0,0 +1,277 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+
+// Type definitions for save operations
+export interface McpServerConfig {
+  type: 'stdio' | 'sse' | 'http';
+  command?: string;
+  args?: string[];
+  url?: string;
+  env?: Record<string, string>;
+}
+
+export interface SkillConfig {
+  name: string;
+  path: string;
+  content: string;
+}
+
+export interface CommandConfig {
+  name: string;
+  path: string;
+  content: string;
+}
+
+export interface AgentConfig {
+  name: string;
+  path: string;
+  content: string;
+}
+
+export interface McpSettingsUpdate {
+  mcpServers: Record<string, McpServerConfig>;
+}
+
+export interface ClaudeConfigExport {
+  skills: SkillConfig[];
+  commands: CommandConfig[];
+  agents: AgentConfig[];
+  mcpSettings: McpSettingsUpdate | null;
+}
+
+export type SaveLocation = 'local' | 'global';
+
+export interface SaveOptions {
+  location: SaveLocation;
+  includeSkills: boolean;
+  includeCommands: boolean;
+  includeAgents: boolean;
+  includeMcpSettings: boolean;
+}
+
+export interface SaveItemResult {
+  name: string;
+  path: string;
+  success: boolean;
+  error?: string;
+}
+
+export interface SaveResult {
+  success: boolean;
+  skills: SaveItemResult[];
+  commands: SaveItemResult[];
+  agents: SaveItemResult[];
+  mcpSettings: { success: boolean; error?: string } | null;
+  errors: { type: string; name: string; error: string }[];
+}
+
+export class FileService {
+  private projectRoot: string;
+
+  constructor(projectRoot?: string) {
+    this.projectRoot = projectRoot || process.cwd();
+  }
+
+  /**
+   * Resolves a path, expanding ~ to home directory
+   */
+  private resolvePath(filePath: string): string {
+    if (filePath.startsWith('~')) {
+      return path.join(os.homedir(), filePath.slice(1));
+    }
+    if (path.isAbsolute(filePath)) {
+      return filePath;
+    }
+    return path.join(this.projectRoot, filePath);
+  }
+
+  /**
+   * Ensures a directory exists
+   */
+  private async ensureDir(dirPath: string): Promise<void> {
+    const resolvedPath = this.resolvePath(dirPath);
+    await fs.mkdir(resolvedPath, { recursive: true });
+  }
+
+  /**
+   * Writes content to a file, creating directories as needed
+   */
+  private async writeFile(filePath: string, content: string): Promise<void> {
+    const resolvedPath = this.resolvePath(filePath);
+    const dirPath = path.dirname(resolvedPath);
+    await this.ensureDir(dirPath);
+    await fs.writeFile(resolvedPath, content, 'utf-8');
+  }
+
+  /**
+   * Saves a skill configuration
+   */
+  async saveSkill(config: SkillConfig): Promise<SaveItemResult> {
+    try {
+      await this.writeFile(config.path, config.content);
+      return { name: config.name, path: config.path, success: true };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      return { name: config.name, path: config.path, success: false, error: errorMessage };
+    }
+  }
+
+  /**
+   * Saves a command configuration
+   */
+  async saveCommand(config: CommandConfig): Promise<SaveItemResult> {
+    try {
+      await this.writeFile(config.path, config.content);
+      return { name: config.name, path: config.path, success: true };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      return { name: config.name, path: config.path, success: false, error: errorMessage };
+    }
+  }
+
+  /**
+   * Saves an agent configuration
+   */
+  async saveAgent(config: AgentConfig): Promise<SaveItemResult> {
+    try {
+      await this.writeFile(config.path, config.content);
+      return { name: config.name, path: config.path, success: true };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      return { name: config.name, path: config.path, success: false, error: errorMessage };
+    }
+  }
+
+  /**
+   * Updates MCP settings in settings.local.json
+   */
+  async updateMcpSettings(
+    settings: McpSettingsUpdate,
+    location: SaveLocation
+  ): Promise<{ success: boolean; error?: string }> {
+    try {
+      const settingsPath = location === 'global'
+        ? '~/.claude/settings.local.json'
+        : '.claude/settings.local.json';
+
+      const resolvedPath = this.resolvePath(settingsPath);
+
+      // Read existing settings if they exist
+      let existingSettings: Record<string, unknown> = {};
+      try {
+        const content = await fs.readFile(resolvedPath, 'utf-8');
+        existingSettings = JSON.parse(content);
+      } catch {
+        // File doesn't exist or is invalid, start fresh
+      }
+
+      // Merge MCP servers
+      const existingMcpServers = (existingSettings.mcpServers as Record<string, unknown>) || {};
+      const mergedSettings = {
+        ...existingSettings,
+        mcpServers: {
+          ...existingMcpServers,
+          ...settings.mcpServers,
+        },
+      };
+
+      // Write updated settings
+      const dirPath = path.dirname(resolvedPath);
+      await this.ensureDir(dirPath);
+      await fs.writeFile(resolvedPath, JSON.stringify(mergedSettings, null, 2), 'utf-8');
+
+      return { success: true };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      return { success: false, error: errorMessage };
+    }
+  }
+
+  /**
+   * Saves an entire workflow configuration
+   */
+  async saveWorkflow(config: ClaudeConfigExport, options: SaveOptions): Promise<SaveResult> {
+    const result: SaveResult = {
+      success: true,
+      skills: [],
+      commands: [],
+      agents: [],
+      mcpSettings: null,
+      errors: [],
+    };
+
+    // Save skills
+    if (options.includeSkills) {
+      for (const skill of config.skills) {
+        const skillResult = await this.saveSkill(skill);
+        result.skills.push(skillResult);
+        if (!skillResult.success) {
+          result.success = false;
+          result.errors.push({
+            type: 'skill',
+            name: skill.name,
+            error: skillResult.error || 'Unknown error',
+          });
+        }
+      }
+    }
+
+    // Save commands
+    if (options.includeCommands) {
+      for (const command of config.commands) {
+        const commandResult = await this.saveCommand(command);
+        result.commands.push(commandResult);
+        if (!commandResult.success) {
+          result.success = false;
+          result.errors.push({
+            type: 'command',
+            name: command.name,
+            error: commandResult.error || 'Unknown error',
+          });
+        }
+      }
+    }
+
+    // Save agents
+    if (options.includeAgents) {
+      for (const agent of config.agents) {
+        const agentResult = await this.saveAgent(agent);
+        result.agents.push(agentResult);
+        if (!agentResult.success) {
+          result.success = false;
+          result.errors.push({
+            type: 'agent',
+            name: agent.name,
+            error: agentResult.error || 'Unknown error',
+          });
+        }
+      }
+    }
+
+    // Update MCP settings
+    if (options.includeMcpSettings && config.mcpSettings) {
+      const mcpResult = await this.updateMcpSettings(config.mcpSettings, options.location);
+      result.mcpSettings = mcpResult;
+      if (!mcpResult.success) {
+        result.success = false;
+        result.errors.push({
+          type: 'mcp',
+          name: 'settings.local.json',
+          error: mcpResult.error || 'Unknown error',
+        });
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Gets the project root path
+   */
+  getProjectPath(): string {
+    return this.projectRoot;
+  }
+}
+
+export const fileService = new FileService();