claude-space 2.0.0

package/out/preload/index.js

@@ -0,0 +1,250 @@
+"use strict";
+const electron = require("electron");
+const preload = require("@electron-toolkit/preload");
+const api = {
+  // File selection
+  selectFile: () => electron.ipcRenderer.invoke("select-file"),
+  // Open path in system file manager
+  openPath: (path) => electron.ipcRenderer.invoke("open-path", path),
+  // Memory Panel file operations
+  listMarkdownFiles: (folderPath) => electron.ipcRenderer.invoke("list-markdown-files", folderPath),
+  addMarkdownFile: (folderPath, sourcePath, fileName) => electron.ipcRenderer.invoke("add-markdown-file", folderPath, sourcePath, fileName),
+  deleteMarkdownFile: (filePath) => electron.ipcRenderer.invoke("delete-markdown-file", filePath),
+  // Skills Panel operations
+  skills: {
+    initialize: (projectPath, skillName) => electron.ipcRenderer.invoke("initialize-skill", projectPath, skillName),
+    load: (projectPath, skillName) => electron.ipcRenderer.invoke("load-skill", projectPath, skillName),
+    saveMd: (projectPath, skillName, content) => electron.ipcRenderer.invoke("save-skill-md", projectPath, skillName, content),
+    addFile: (projectPath, skillName, sourcePath, fileName, fileType) => electron.ipcRenderer.invoke("add-skill-file", projectPath, skillName, sourcePath, fileName, fileType),
+    deleteFile: (filePath) => electron.ipcRenderer.invoke("delete-skill-file", filePath),
+    deleteFolder: (projectPath, skillName) => electron.ipcRenderer.invoke("delete-skill-folder", projectPath, skillName),
+    scanFolder: (projectPath) => electron.ipcRenderer.invoke("scan-skills-folder", projectPath)
+  },
+  // Context Drive operations
+  context: {
+    listFiles: (projectPath) => electron.ipcRenderer.invoke("list-context-files", projectPath),
+    addFile: (projectPath, sourcePath, fileName, title, description) => electron.ipcRenderer.invoke("add-context-file", projectPath, sourcePath, fileName, title, description),
+    renameFile: (projectPath, oldName, newName) => electron.ipcRenderer.invoke("rename-context-file", projectPath, oldName, newName),
+    updateMetadata: (projectPath, fileName, title, description) => electron.ipcRenderer.invoke("update-context-metadata", projectPath, fileName, title, description),
+    deleteFile: (projectPath, fileName) => electron.ipcRenderer.invoke("delete-context-file", projectPath, fileName),
+    readFile: (projectPath, fileName) => electron.ipcRenderer.invoke("read-context-file", projectPath, fileName)
+  },
+  // Memory Node operations
+  memoryNode: {
+    listFiles: (projectPath, memoryFolderName) => electron.ipcRenderer.invoke("list-memory-node-files", projectPath, memoryFolderName),
+    addFile: (projectPath, memoryFolderName, sourcePath, fileName, title, description) => electron.ipcRenderer.invoke("add-memory-node-file", projectPath, memoryFolderName, sourcePath, fileName, title, description),
+    renameFile: (projectPath, memoryFolderName, oldName, newName) => electron.ipcRenderer.invoke("rename-memory-node-file", projectPath, memoryFolderName, oldName, newName),
+    updateMetadata: (projectPath, memoryFolderName, fileName, title, description) => electron.ipcRenderer.invoke("update-memory-node-metadata", projectPath, memoryFolderName, fileName, title, description),
+    deleteFile: (projectPath, memoryFolderName, fileName) => electron.ipcRenderer.invoke("delete-memory-node-file", projectPath, memoryFolderName, fileName),
+    readFile: (projectPath, memoryFolderName, fileName) => electron.ipcRenderer.invoke("read-memory-node-file", projectPath, memoryFolderName, fileName),
+    deleteFolder: (projectPath, memoryFolderName) => electron.ipcRenderer.invoke("delete-memory-node-folder", projectPath, memoryFolderName)
+  },
+  // SubAgent operations
+  subagent: {
+    listFiles: (projectPath) => electron.ipcRenderer.invoke("list-subagent-files", projectPath),
+    readFile: (projectPath, fileName) => electron.ipcRenderer.invoke("read-subagent-file", projectPath, fileName),
+    writeFile: (projectPath, fileName, frontmatter, markdown) => electron.ipcRenderer.invoke("write-subagent-file", projectPath, fileName, frontmatter, markdown),
+    renameFile: (projectPath, oldFileName, newFileName) => electron.ipcRenderer.invoke("rename-subagent-file", projectPath, oldFileName, newFileName),
+    deleteFile: (projectPath, fileName) => electron.ipcRenderer.invoke("delete-subagent-file", projectPath, fileName),
+    scanFolder: (projectPath) => electron.ipcRenderer.invoke("scan-agents-folder", projectPath)
+  },
+  // Command operations
+  command: {
+    listFiles: (projectPath) => electron.ipcRenderer.invoke("list-command-files", projectPath),
+    readFile: (projectPath, fileName) => electron.ipcRenderer.invoke("read-command-file", projectPath, fileName),
+    writeFile: (projectPath, fileName, frontmatter, markdown) => electron.ipcRenderer.invoke("write-command-file", projectPath, fileName, frontmatter, markdown),
+    renameFile: (projectPath, oldFileName, newFileName) => electron.ipcRenderer.invoke("rename-command-file", projectPath, oldFileName, newFileName),
+    deleteFile: (projectPath, fileName) => electron.ipcRenderer.invoke("delete-command-file", projectPath, fileName),
+    scanFolder: (projectPath) => electron.ipcRenderer.invoke("scan-commands-folder", projectPath)
+  },
+  // Hook operations
+  hook: {
+    listFiles: (projectPath) => electron.ipcRenderer.invoke("list-hook-files", projectPath),
+    readFile: (projectPath, fileName) => electron.ipcRenderer.invoke("read-hook-file", projectPath, fileName),
+    writeFile: (projectPath, fileName, content) => electron.ipcRenderer.invoke("write-hook-file", projectPath, fileName, content),
+    renameFile: (projectPath, oldFileName, newFileName) => electron.ipcRenderer.invoke("rename-hook-file", projectPath, oldFileName, newFileName),
+    deleteFile: (projectPath, fileName) => electron.ipcRenderer.invoke("delete-hook-file", projectPath, fileName),
+    scanFolder: (projectPath) => electron.ipcRenderer.invoke("scan-hooks-folder", projectPath)
+  },
+  // Workspace operations (kept for migration only)
+  workspace: {
+    listProjects: (workspacePath) => electron.ipcRenderer.invoke("list-projects", workspacePath)
+  },
+  // Project operations
+  project: {
+    selectFolder: () => electron.ipcRenderer.invoke("select-project-folder"),
+    validate: (projectPath) => electron.ipcRenderer.invoke("validate-project", projectPath),
+    checkClaudeFolder: (projectPath) => electron.ipcRenderer.invoke("check-claude-folder", projectPath),
+    createAt: (targetPath, projectName) => electron.ipcRenderer.invoke("create-project-at", targetPath, projectName),
+    save: (projectPath, workflowData) => electron.ipcRenderer.invoke("save-project", projectPath, workflowData),
+    load: (projectPath) => electron.ipcRenderer.invoke("load-project", projectPath),
+    delete: (projectPath) => electron.ipcRenderer.invoke("delete-project", projectPath),
+    selectExportLocation: () => electron.ipcRenderer.invoke("select-export-location"),
+    exportClaudeFolder: (exportPath, projectName, exportData) => electron.ipcRenderer.invoke("export-claude-folder", exportPath, projectName, exportData),
+    selectImportFolder: () => electron.ipcRenderer.invoke("select-import-folder"),
+    importClaudeFolder: (claudeFolderPath) => electron.ipcRenderer.invoke("import-claude-folder", claudeFolderPath),
+    listSourceFiles: (projectPath) => electron.ipcRenderer.invoke("list-project-files", projectPath)
+  },
+  // Settings.local operations
+  settingsLocal: {
+    load: (projectPath) => electron.ipcRenderer.invoke("load-settings-local", projectPath),
+    save: (projectPath, settings) => electron.ipcRenderer.invoke("save-settings-local", projectPath, settings)
+  },
+  // .mcp.json operations (MCP servers at project root)
+  mcpJson: {
+    load: (projectPath) => electron.ipcRenderer.invoke("load-mcp-json", projectPath),
+    save: (projectPath, mcpJson) => electron.ipcRenderer.invoke("save-mcp-json", projectPath, mcpJson)
+  },
+  // Agent operations
+  agent: {
+    startSession: (projectPath, apiKey, authMethod, sdkSessionId, permissionMode, agentFolderName) => electron.ipcRenderer.invoke("agent:start-session", projectPath, apiKey, authMethod, sdkSessionId, permissionMode, agentFolderName),
+    sendMessage: (sessionId, message) => electron.ipcRenderer.invoke("agent:send-message", sessionId, message),
+    stopSession: (sessionId) => electron.ipcRenderer.invoke("agent:stop-session", sessionId),
+    isSessionActive: (sessionId) => electron.ipcRenderer.invoke("agent:is-session-active", sessionId),
+    setPermissionMode: (sessionId, mode) => electron.ipcRenderer.invoke("agent:set-permission-mode", sessionId, mode),
+    respondToApproval: (sessionId, requestId, approved) => electron.ipcRenderer.invoke("agent:respond-to-approval", sessionId, requestId, approved),
+    onMessageChunk: (callback) => {
+      const listener = (_, sessionId, chunk) => callback(sessionId, chunk);
+      electron.ipcRenderer.on("agent:message-chunk", listener);
+      return listener;
+    },
+    onMessageComplete: (callback) => {
+      const listener = (_, sessionId) => callback(sessionId);
+      electron.ipcRenderer.on("agent:message-complete", listener);
+      return listener;
+    },
+    removeMessageChunkListener: (listener) => electron.ipcRenderer.removeListener("agent:message-chunk", listener),
+    removeMessageCompleteListener: (listener) => electron.ipcRenderer.removeListener("agent:message-complete", listener)
+  },
+  // API Key management operations
+  keys: {
+    hasAnthropicKey: (projectPath) => electron.ipcRenderer.invoke("keys:has-anthropic", projectPath),
+    getAnthropicKey: (projectPath) => electron.ipcRenderer.invoke("keys:get-anthropic", projectPath),
+    setAnthropicKey: (apiKey, projectPath) => electron.ipcRenderer.invoke("keys:set-anthropic", apiKey, projectPath),
+    deleteAnthropicKey: (projectPath) => electron.ipcRenderer.invoke("keys:delete-anthropic", projectPath)
+  },
+  // Authentication management operations
+  auth: {
+    checkCliStatus: () => electron.ipcRenderer.invoke("auth:check-cli-status"),
+    getPreferredMethod: (projectPath) => electron.ipcRenderer.invoke("auth:get-preferred-method", projectPath),
+    setPreferredMethod: (method, projectPath) => electron.ipcRenderer.invoke("auth:set-preferred-method", method, projectPath),
+    getAutoFallback: () => electron.ipcRenderer.invoke("auth:get-auto-fallback"),
+    setAutoFallback: (enabled) => electron.ipcRenderer.invoke("auth:set-auto-fallback", enabled),
+    getCustomCliCommand: () => electron.ipcRenderer.invoke("auth:get-custom-cli-command"),
+    setCustomCliCommand: (command) => electron.ipcRenderer.invoke("auth:set-custom-cli-command", command),
+    clearCustomCliCommand: () => electron.ipcRenderer.invoke("auth:clear-custom-cli-command")
+  },
+  // Logs operations
+  logs: {
+    load: (projectPath) => electron.ipcRenderer.invoke("logs:load", projectPath),
+    save: (projectPath, logs) => electron.ipcRenderer.invoke("logs:save", projectPath, logs)
+  },
+  // Music (offline, workspace-aware)
+  music: {
+    listTracks: (workspacePath) => electron.ipcRenderer.invoke("music:list-tracks", workspacePath),
+    selectTracks: () => electron.ipcRenderer.invoke("music:select-tracks"),
+    addTracks: (workspacePath, sourcePaths) => electron.ipcRenderer.invoke("music:add-tracks", workspacePath, sourcePaths),
+    ensureWorkspaceMusic: (workspacePath) => electron.ipcRenderer.invoke("music:ensure-workspace-music", workspacePath),
+    getWorkspaceMusicPath: (workspacePath) => electron.ipcRenderer.invoke("music:get-workspace-music-path", workspacePath),
+    readTrack: (filePath) => electron.ipcRenderer.invoke("music:read-track", filePath)
+  },
+  // Icon Management operations (Global Storage)
+  icons: {
+    list: () => electron.ipcRenderer.invoke("icons:list"),
+    add: (sourcePath) => electron.ipcRenderer.invoke("icons:add", sourcePath),
+    delete: (fileName) => electron.ipcRenderer.invoke("icons:delete", fileName),
+    selectFiles: () => electron.ipcRenderer.invoke("icons:select-files"),
+    readFile: (filePath) => electron.ipcRenderer.invoke("icons:read-file", filePath)
+  },
+  // Global Node Library operations
+  nodeLibrary: {
+    // MCP operations
+    mcp: {
+      list: () => electron.ipcRenderer.invoke("nodeLibrary:mcp:list"),
+      get: (id) => electron.ipcRenderer.invoke("nodeLibrary:mcp:get", id),
+      create: (data) => electron.ipcRenderer.invoke("nodeLibrary:mcp:create", data),
+      update: (id, data) => electron.ipcRenderer.invoke("nodeLibrary:mcp:update", id, data),
+      delete: (id) => electron.ipcRenderer.invoke("nodeLibrary:mcp:delete", id)
+    },
+    // Hook operations (legacy)
+    hook: {
+      list: () => electron.ipcRenderer.invoke("nodeLibrary:hook:list"),
+      get: (id) => electron.ipcRenderer.invoke("nodeLibrary:hook:get", id),
+      create: (data) => electron.ipcRenderer.invoke("nodeLibrary:hook:create", data),
+      update: (id, data) => electron.ipcRenderer.invoke("nodeLibrary:hook:update", id, data),
+      delete: (id) => electron.ipcRenderer.invoke("nodeLibrary:hook:delete", id)
+    },
+    // Hook Config operations (new Claude Code format)
+    hookconfig: {
+      list: () => electron.ipcRenderer.invoke("nodeLibrary:hookconfig:list"),
+      get: (id) => electron.ipcRenderer.invoke("nodeLibrary:hookconfig:get", id),
+      create: (data) => electron.ipcRenderer.invoke("nodeLibrary:hookconfig:create", data),
+      update: (id, data) => electron.ipcRenderer.invoke("nodeLibrary:hookconfig:update", id, data),
+      delete: (id) => electron.ipcRenderer.invoke("nodeLibrary:hookconfig:delete", id)
+    },
+    // SubAgent operations
+    subagent: {
+      list: () => electron.ipcRenderer.invoke("nodeLibrary:subagent:list"),
+      get: (id) => electron.ipcRenderer.invoke("nodeLibrary:subagent:get", id),
+      create: (data) => electron.ipcRenderer.invoke("nodeLibrary:subagent:create", data),
+      update: (id, data) => electron.ipcRenderer.invoke("nodeLibrary:subagent:update", id, data),
+      delete: (id) => electron.ipcRenderer.invoke("nodeLibrary:subagent:delete", id)
+    },
+    // Command operations
+    command: {
+      list: () => electron.ipcRenderer.invoke("nodeLibrary:command:list"),
+      get: (id) => electron.ipcRenderer.invoke("nodeLibrary:command:get", id),
+      create: (data) => electron.ipcRenderer.invoke("nodeLibrary:command:create", data),
+      update: (id, data) => electron.ipcRenderer.invoke("nodeLibrary:command:update", id, data),
+      delete: (id) => electron.ipcRenderer.invoke("nodeLibrary:command:delete", id)
+    },
+    // Skill operations (folder-based)
+    skill: {
+      list: () => electron.ipcRenderer.invoke("nodeLibrary:skill:list"),
+      get: (id) => electron.ipcRenderer.invoke("nodeLibrary:skill:get", id),
+      create: (data) => electron.ipcRenderer.invoke("nodeLibrary:skill:create", data),
+      update: (id, data) => electron.ipcRenderer.invoke("nodeLibrary:skill:update", id, data),
+      delete: (id) => electron.ipcRenderer.invoke("nodeLibrary:skill:delete", id),
+      addFile: (id, fileType, sourcePath, fileName) => electron.ipcRenderer.invoke("nodeLibrary:skill:addFile", id, fileType, sourcePath, fileName),
+      deleteFile: (id, fileType, fileName) => electron.ipcRenderer.invoke("nodeLibrary:skill:deleteFile", id, fileType, fileName),
+      copyToProject: (skillId, projectPath, forceSync, targetFolderName) => electron.ipcRenderer.invoke("nodeLibrary:skill:copyToProject", skillId, projectPath, forceSync, targetFolderName)
+    },
+    // Memory operations (folder-based)
+    memory: {
+      list: () => electron.ipcRenderer.invoke("nodeLibrary:memory:list"),
+      get: (id) => electron.ipcRenderer.invoke("nodeLibrary:memory:get", id),
+      create: (data) => electron.ipcRenderer.invoke("nodeLibrary:memory:create", data),
+      update: (id, data) => electron.ipcRenderer.invoke("nodeLibrary:memory:update", id, data),
+      delete: (id) => electron.ipcRenderer.invoke("nodeLibrary:memory:delete", id),
+      addFile: (id, sourcePath, fileName, title, description) => electron.ipcRenderer.invoke("nodeLibrary:memory:addFile", id, sourcePath, fileName, title, description),
+      deleteFile: (id, fileName) => electron.ipcRenderer.invoke("nodeLibrary:memory:deleteFile", id, fileName),
+      copyToProject: (memoryId, projectPath, forceSync, targetFolderName) => electron.ipcRenderer.invoke(
+        "nodeLibrary:memory:copyToProject",
+        memoryId,
+        projectPath,
+        forceSync,
+        targetFolderName
+      )
+    },
+    // Migration
+    migrate: {
+      fromNodeData: () => electron.ipcRenderer.invoke("nodeLibrary:migrate:fromNodeData")
+    }
+  },
+  // App management
+  app: {
+    clearCache: () => electron.ipcRenderer.invoke("app:clear-cache"),
+    restart: () => electron.ipcRenderer.invoke("app:restart")
+  }
+};
+if (process.contextIsolated) {
+  try {
+    electron.contextBridge.exposeInMainWorld("electron", preload.electronAPI);
+    electron.contextBridge.exposeInMainWorld("api", api);
+  } catch (error) {
+    console.error(error);
+  }
+} else {
+  window.electron = preload.electronAPI;
+  window.api = api;
+}

package/out/renderer/assets/claudeFolderGenerator-BgGHew94.js

@@ -0,0 +1,179 @@
+function generateClaudeFolder(nodes, edges, _projectName) {
+  const mainCard = nodes.find((n) => n.id === "main-card");
+  if (!mainCard) {
+    throw new Error("Main agent card not found in workflow");
+  }
+  const connections = categorizeConnections(nodes, edges);
+  const mainAgent = buildMainAgent(mainCard);
+  const settings = {
+    version: "1.0",
+    agents: [mainAgent],
+    skills: connections.skills.map((skill) => ({
+      id: skill.id,
+      path: `skills/${skill.fileName}`,
+      enabled: true
+    })),
+    memory: connections.memory.map((mem) => ({
+      id: mem.id,
+      path: `memory/${mem.fileName}`,
+      type: mem.type || "markdown"
+    }))
+  };
+  const agents = /* @__PURE__ */ new Map();
+  agents.set("main", generateAgentFile(mainAgent));
+  connections.subagents.forEach((subagent) => {
+    const subagentDef = buildSubagent(subagent);
+    agents.set(subagent.id, generateAgentFile(subagentDef));
+    settings.agents.push(subagentDef);
+  });
+  const skills = /* @__PURE__ */ new Map();
+  connections.skills.forEach((skill) => {
+    skills.set(skill.fileName, skill.content || "");
+  });
+  const memory = /* @__PURE__ */ new Map();
+  connections.memory.forEach((mem) => {
+    memory.set(mem.fileName, mem.content || "");
+  });
+  const settingsLocal = {
+    ...mainCard.data.claudeSettings || {}
+  };
+  delete settingsLocal.mcpServers;
+  delete settingsLocal.enableAllProjectMcpServers;
+  if (connections.hooks.length > 0) {
+    const mergedHooks = {};
+    connections.hooks.forEach((hookNode) => {
+      if (hookNode.hooks && typeof hookNode.hooks === "object") {
+        Object.entries(hookNode.hooks).forEach(([eventType, entries]) => {
+          if (!mergedHooks[eventType]) {
+            mergedHooks[eventType] = [];
+          }
+          if (Array.isArray(entries)) {
+            mergedHooks[eventType].push(...entries);
+          }
+        });
+      }
+    });
+    if (Object.keys(mergedHooks).length > 0) {
+      settingsLocal.hooks = mergedHooks;
+    }
+  }
+  const mcpJson = connections.mcp.length > 0 ? {
+    mcpServers: connections.mcp.reduce((acc, mcp) => {
+      acc[mcp.name || mcp.label || mcp.id] = {
+        command: mcp.command || "",
+        args: mcp.args || [],
+        ...mcp.env && { env: mcp.env }
+      };
+      return acc;
+    }, {})
+  } : void 0;
+  return {
+    settings,
+    settingsLocal,
+    mcpJson,
+    agents,
+    skills,
+    memory
+  };
+}
+function categorizeConnections(nodes, edges) {
+  const connections = {
+    interface: [],
+    memory: [],
+    skills: [],
+    mcp: [],
+    subagents: [],
+    hooks: []
+  };
+  const mainCardEdges = edges.filter((edge) => edge.source === "main-card");
+  mainCardEdges.forEach((edge) => {
+    const targetNode = nodes.find((n) => n.id === edge.target);
+    if (!targetNode) return;
+    switch (edge.sourceHandle) {
+      case "top-left":
+        connections.hooks.push(extractNodeData(targetNode));
+        break;
+      case "bottom-left":
+        connections.memory.push(extractNodeData(targetNode));
+        break;
+      case "right-center":
+        connections.skills.push(extractNodeData(targetNode));
+        break;
+      case "top-right":
+        connections.mcp.push(extractNodeData(targetNode));
+        break;
+      case "bottom-center":
+        connections.subagents.push(extractNodeData(targetNode));
+        break;
+    }
+  });
+  return connections;
+}
+function extractNodeData(node) {
+  const { label: _originalLabel, ...restData } = node.data;
+  return {
+    id: node.id,
+    type: node.type,
+    label: node.data.label || node.id,
+    ...restData
+  };
+}
+function buildMainAgent(mainCard, _connections) {
+  const data = mainCard.data;
+  return {
+    id: "main",
+    name: data.name || data.label || "Main Agent",
+    description: data.description || "Main agent for this workflow",
+    systemPrompt: data.systemPrompt || data.agentDefinition || "",
+    temperature: data.temperature || 0.7,
+    maxTokens: data.maxTokens || 4096,
+    tools: Array.isArray(data.tools) ? data.tools : data.tools ? [data.tools] : []
+  };
+}
+function buildSubagent(subagentData) {
+  return {
+    id: subagentData.id,
+    name: subagentData.label || subagentData.name || subagentData.id,
+    description: subagentData.description || "",
+    systemPrompt: subagentData.systemPrompt || subagentData.agentDefinition || "",
+    temperature: subagentData.temperature || 0.7,
+    maxTokens: subagentData.maxTokens || 4096,
+    tools: subagentData.tools || []
+  };
+}
+function generateAgentFile(agent) {
+  return `# ${agent.name}
+
+${agent.description || ""}
+
+## System Prompt
+
+${agent.systemPrompt || "No system prompt defined."}
+
+## Configuration
+
+- Temperature: ${agent.temperature}
+- Max Tokens: ${agent.maxTokens}
+- Tools: ${agent.tools?.join(", ") || "None"}
+`;
+}
+function validateExportData(exportData) {
+  const errors = [];
+  if (!exportData.settings) {
+    errors.push("Missing settings");
+  }
+  if (!exportData.settings.agents || exportData.settings.agents.length === 0) {
+    errors.push("No agents defined");
+  }
+  if (!exportData.agents.has("main")) {
+    errors.push("Main agent file not generated");
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+export {
+  generateClaudeFolder,
+  validateExportData
+};