@sylphx/flow 1.0.0 → 1.0.1

package/dist/shared/chunk-nd5fdvaq.js

@@ -0,0 +1,26 @@
+// src/core/functional/result.ts
+var success = (value) => ({
+  _tag: "Success",
+  value
+});
+var failure = (error) => ({
+  _tag: "Failure",
+  error
+});
+var tryCatch = (fn, onError = (error) => error) => {
+  try {
+    return success(fn());
+  } catch (error) {
+    return failure(onError(error));
+  }
+};
+var tryCatchAsync = async (fn, onError = (error) => error) => {
+  try {
+    const value = await fn();
+    return success(value);
+  } catch (error) {
+    return failure(onError(error));
+  }
+};
+
+export { success, failure, tryCatch, tryCatchAsync };

package/dist/shared/chunk-pgd3m6zf.js

@@ -0,0 +1,108 @@
+import {
+  configError
+} from "./chunk-t4fbfa5v.js";
+import {
+  failure,
+  success,
+  tryCatch
+} from "./chunk-nd5fdvaq.js";
+import"./chunk-5j4w74t6.js";
+
+// src/targets/functional/claude-code-logic.ts
+var generateHookCommands = async (targetId) => {
+  return {
+    sessionCommand: `sylphx-flow hook --type session --target ${targetId}`,
+    notificationCommand: `sylphx-flow hook --type notification --target ${targetId}`
+  };
+};
+var DEFAULT_HOOKS = {
+  sessionCommand: "sylphx-flow hook --type session --target claude-code",
+  notificationCommand: "sylphx-flow hook --type notification --target claude-code"
+};
+var parseSettings = (content) => {
+  return tryCatch(() => JSON.parse(content), (error) => configError("Failed to parse Claude Code settings", {
+    cause: error instanceof Error ? error : undefined
+  }));
+};
+var buildHookConfiguration = (config = DEFAULT_HOOKS) => {
+  const sessionCommand = config.sessionCommand || DEFAULT_HOOKS.sessionCommand;
+  const notificationCommand = config.notificationCommand || DEFAULT_HOOKS.notificationCommand;
+  return {
+    SessionStart: [
+      {
+        hooks: [
+          {
+            type: "command",
+            command: sessionCommand
+          }
+        ]
+      }
+    ],
+    Notification: [
+      {
+        matcher: "",
+        hooks: [
+          {
+            type: "command",
+            command: notificationCommand
+          }
+        ]
+      }
+    ]
+  };
+};
+var mergeSettings = (existingSettings, hookConfig = DEFAULT_HOOKS) => {
+  const newHooks = buildHookConfiguration(hookConfig);
+  return {
+    ...existingSettings,
+    hooks: {
+      ...existingSettings.hooks || {},
+      ...newHooks
+    }
+  };
+};
+var createSettings = (hookConfig = DEFAULT_HOOKS) => {
+  return {
+    hooks: buildHookConfiguration(hookConfig)
+  };
+};
+var serializeSettings = (settings) => {
+  return JSON.stringify(settings, null, 2);
+};
+var getSuccessMessage = () => {
+  return "Claude Code hooks configured: SessionStart (static info) + UserPromptSubmit (dynamic info)";
+};
+var processSettings = (existingContent, hookConfig = DEFAULT_HOOKS) => {
+  if (existingContent === null || existingContent.trim() === "") {
+    const settings = createSettings(hookConfig);
+    return success(serializeSettings(settings));
+  }
+  const parseResult = parseSettings(existingContent);
+  if (parseResult._tag === "Failure") {
+    const settings = createSettings(hookConfig);
+    return success(serializeSettings(settings));
+  }
+  const merged = mergeSettings(parseResult.value, hookConfig);
+  return success(serializeSettings(merged));
+};
+var validateHookConfig = (config) => {
+  if (config.sessionCommand !== undefined && config.sessionCommand.trim() === "") {
+    return failure(configError("Session command cannot be empty"));
+  }
+  if (config.messageCommand !== undefined && config.messageCommand.trim() === "") {
+    return failure(configError("Message command cannot be empty"));
+  }
+  return success(config);
+};
+export {
+  validateHookConfig,
+  serializeSettings,
+  processSettings,
+  parseSettings,
+  mergeSettings,
+  getSuccessMessage,
+  generateHookCommands,
+  createSettings,
+  buildHookConfiguration,
+  DEFAULT_HOOKS
+};

package/dist/shared/chunk-qk8n91hw.js

@@ -0,0 +1,494 @@
+import {
+  CLIError,
+  FileInstaller,
+  MCPInstaller,
+  opencodeTarget
+} from "./chunk-cjd3mk4c.js";
+import {
+  getAgentsDir,
+  getSlashCommandsDir
+} from "./chunk-t16rfxh0.js";
+import {
+  fileUtils,
+  generateHelpText,
+  pathUtils,
+  sanitize,
+  yamlUtils
+} from "./chunk-hpkhykhq.js";
+import {
+  __require,
+  __toESM
+} from "./chunk-5j4w74t6.js";
+
+// src/core/functional/option.ts
+var some = (value) => ({
+  _tag: "Some",
+  value
+});
+var none = {
+  _tag: "None"
+};
+var isSome = (option) => option._tag === "Some";
+var getOrElse = (defaultValue) => (option) => {
+  if (isSome(option)) {
+    return option.value;
+  }
+  return defaultValue;
+};
+
+// src/targets/claude-code.ts
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import fsPromises from "node:fs/promises";
+import path from "node:path";
+var claudeCodeTarget = {
+  id: "claude-code",
+  name: "Claude Code",
+  description: "Claude Code CLI with YAML front matter agents (.claude/agents/*.md)",
+  category: "cli",
+  isImplemented: true,
+  isDefault: false,
+  mcpServerConfig: {
+    disableTime: true,
+    disableKnowledge: false,
+    disableCodebase: true
+  },
+  config: {
+    agentDir: ".claude/agents",
+    agentExtension: ".md",
+    agentFormat: "yaml-frontmatter",
+    stripYaml: false,
+    flatten: false,
+    configFile: ".mcp.json",
+    configSchema: null,
+    mcpConfigPath: "mcpServers",
+    rulesFile: undefined,
+    outputStylesDir: undefined,
+    slashCommandsDir: ".claude/commands",
+    installation: {
+      createAgentDir: true,
+      createConfigFile: true,
+      useSecretFiles: false
+    }
+  },
+  async transformAgentContent(content, metadata, sourcePath) {
+    const { metadata: existingMetadata, content: baseContent } = await yamlUtils.extractFrontMatter(content);
+    const claudeCodeMetadata = convertToClaudeCodeFormat(existingMetadata, baseContent, sourcePath);
+    if (metadata) {
+      Object.assign(claudeCodeMetadata, metadata);
+    }
+    return yamlUtils.addFrontMatter(baseContent, claudeCodeMetadata);
+  },
+  transformMCPConfig(config, _serverId) {
+    if (config.type === "local") {
+      const [command, ...args] = config.command;
+      return {
+        type: "stdio",
+        command,
+        ...args && args.length > 0 && { args },
+        ...config.environment && { env: config.environment }
+      };
+    }
+    if (config.type === "stdio") {
+      return {
+        type: "stdio",
+        command: config.command,
+        ...config.args && config.args.length > 0 && { args: config.args },
+        ...config.env && { env: config.env }
+      };
+    }
+    if (config.type === "remote") {
+      return {
+        type: "http",
+        url: config.url,
+        ...config.headers && { headers: config.headers }
+      };
+    }
+    if (config.type === "http") {
+      return {
+        type: "http",
+        url: config.url,
+        ...config.headers && { headers: config.headers }
+      };
+    }
+    return config;
+  },
+  getConfigPath: (cwd) => Promise.resolve(fileUtils.getConfigPath(claudeCodeTarget.config, cwd)),
+  async readConfig(cwd) {
+    const config = await fileUtils.readConfig(claudeCodeTarget.config, cwd);
+    if (!config.mcpServers) {
+      config.mcpServers = {};
+    }
+    return config;
+  },
+  async writeConfig(cwd, config) {
+    if (!config.mcpServers) {
+      config.mcpServers = {};
+    }
+    await fileUtils.writeConfig(claudeCodeTarget.config, cwd, config);
+  },
+  validateRequirements: (cwd) => fileUtils.validateRequirements(claudeCodeTarget.config, cwd),
+  getHelpText() {
+    let help = generateHelpText(claudeCodeTarget.config);
+    help += `Claude Code-Specific Information:
+`;
+    help += `  Configuration File: .mcp.json
+`;
+    help += `  Agent Format: Markdown with YAML front matter
+`;
+    help += `  MCP Integration: Full server support
+
+`;
+    help += `Example Agent Structure:
+`;
+    help += `  ---
+`;
+    help += `  name: "code-reviewer"
+`;
+    help += `  description: "Expert code review specialist"
+`;
+    help += `  ---
+
+`;
+    help += `  Agent content here...
+
+`;
+    help += `Note: Only 'name' and 'description' fields are supported.
+`;
+    help += `Tools field omitted to allow all tools by default (whitelist model limitation).
+`;
+    help += `Unsupported fields (mode, temperature, etc.) are automatically removed.
+
+`;
+    help += `Example MCP Configuration:
+`;
+    help += `  {
+`;
+    help += `    "mcpServers": {
+`;
+    help += `      "filesystem": {
+`;
+    help += `        "type": "stdio",
+`;
+    help += `        "command": "npx",
+`;
+    help += `        "args": ["@modelcontextprotocol/server-filesystem", "/path/to/allowed/dir"]
+`;
+    help += `      },
+`;
+    help += `      "git": {
+`;
+    help += `        "type": "stdio",
+`;
+    help += `        "command": "npx",
+`;
+    help += `        "args": ["@modelcontextprotocol/server-git", "."],
+`;
+    help += `        "env": {
+`;
+    help += `          "GIT_TRACE": "1"
+`;
+    help += `        }
+`;
+    help += `      },
+`;
+    help += `      "api-server": {
+`;
+    help += `        "type": "http",
+`;
+    help += `        "url": "https://api.example.com/mcp",
+`;
+    help += `        "headers": {
+`;
+    help += `          "Authorization": "Bearer $API_KEY"
+`;
+    help += `        }
+`;
+    help += `      }
+`;
+    help += `    }
+`;
+    help += `  }
+
+`;
+    help += `Note: Environment variables can be expanded in command, args, env, url, and headers.
+
+`;
+    return help;
+  },
+  async executeCommand(systemPrompt, userPrompt, options = {}) {
+    const sanitizedSystemPrompt = sanitize.yamlContent(systemPrompt);
+    const sanitizedUserPrompt = userPrompt.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "");
+    const enhancedSystemPrompt = `${sanitizedSystemPrompt}
+
+Please begin your response with a comprehensive summary of all the instructions and context provided above.`;
+    if (options.dryRun) {
+      const dryRunArgs = ["claude", "--dangerously-skip-permissions"];
+      if (options.print)
+        dryRunArgs.push("-p");
+      if (options.continue)
+        dryRunArgs.push("-c");
+      dryRunArgs.push("--system-prompt", '"<agent content>"');
+      if (sanitizedUserPrompt.trim() !== "") {
+        dryRunArgs.push(`"${sanitizedUserPrompt}"`);
+      }
+      console.log(chalk.cyan("Dry run - Would execute:"));
+      console.log(chalk.bold(dryRunArgs.join(" ")));
+      console.log(chalk.dim(`System prompt: ${enhancedSystemPrompt.length} characters`));
+      console.log(chalk.dim(`User prompt: ${sanitizedUserPrompt.length} characters`));
+      console.log("✓ Dry run completed successfully");
+      return;
+    }
+    try {
+      const args = ["--dangerously-skip-permissions"];
+      if (options.print) {
+        args.push("-p");
+      }
+      if (options.continue) {
+        args.push("-c");
+      }
+      args.push("--system-prompt", enhancedSystemPrompt);
+      if (options.verbose) {
+        console.log("\uD83D\uDE80 Executing Claude Code");
+        console.log(`\uD83D\uDCDD System prompt length: ${enhancedSystemPrompt.length} characters`);
+      }
+      if (sanitizedUserPrompt.trim() !== "") {
+        args.push(sanitizedUserPrompt);
+      }
+      if (options.verbose) {
+        console.log(`\uD83D\uDCDD User prompt length: ${sanitizedUserPrompt.length} characters`);
+      }
+      if (options.verbose) {
+        console.log(`\uD83D\uDE80 Executing: claude ${args.join(" ")}`);
+        console.log("");
+      }
+      await new Promise((resolve, reject) => {
+        const child = spawn("claude", args, {
+          stdio: "inherit",
+          shell: false,
+          env: process.env
+        });
+        child.on("spawn", () => {
+          if (options.verbose) {
+            console.log("✓ Claude Code started");
+          }
+        });
+        child.on("close", (code) => {
+          if (code === 0) {
+            resolve();
+          } else {
+            const error = new Error(`Claude Code exited with code ${code}`);
+            error.code = code;
+            reject(error);
+          }
+        });
+        child.on("error", (error) => {
+          if (options.verbose) {
+            console.error("✗ Error spawning Claude:", error);
+          }
+          reject(error);
+        });
+      });
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new CLIError("Claude Code not found. Please install it first.", "CLAUDE_NOT_FOUND");
+      }
+      if (error.code) {
+        throw new CLIError(`Claude Code exited with code ${error.code}`, "CLAUDE_ERROR");
+      }
+      throw new CLIError(`Failed to execute Claude Code: ${error.message}`, "CLAUDE_ERROR");
+    }
+  },
+  detectFromEnvironment() {
+    try {
+      const cwd = process.cwd();
+      return fs.existsSync(path.join(cwd, ".mcp.json"));
+    } catch {
+      return false;
+    }
+  },
+  async approveMCPServers(cwd, serverNames) {
+    const settingsPath = path.join(cwd, ".claude", "settings.local.json");
+    try {
+      let settings = {};
+      try {
+        const content = await fsPromises.readFile(settingsPath, "utf8");
+        settings = JSON.parse(content);
+      } catch (error) {
+        if (error.code !== "ENOENT") {
+          throw error;
+        }
+      }
+      const existingServers = Array.isArray(settings.enabledMcpjsonServers) ? settings.enabledMcpjsonServers : [];
+      const allServers = [...new Set([...existingServers, ...serverNames])];
+      settings.enabledMcpjsonServers = allServers;
+      await fsPromises.mkdir(path.dirname(settingsPath), { recursive: true });
+      await fsPromises.writeFile(settingsPath, `${JSON.stringify(settings, null, 2)}
+`, "utf8");
+    } catch (error) {
+      throw new Error(`Failed to approve MCP servers: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  },
+  async transformRulesContent(content) {
+    return yamlUtils.stripFrontMatter(content);
+  },
+  async setupHooks(cwd, _options) {
+    const { processSettings, generateHookCommands } = await import("./chunk-pgd3m6zf.js");
+    const { pathExists, createDirectory, readFile, writeFile } = await import("./chunk-25dwp0dp.js");
+    const claudeConfigDir = path.join(cwd, ".claude");
+    const settingsPath = path.join(claudeConfigDir, "settings.json");
+    const dirExistsResult = await pathExists(claudeConfigDir);
+    if (dirExistsResult._tag === "Success" && !dirExistsResult.value) {
+      const createResult = await createDirectory(claudeConfigDir, { recursive: true });
+      if (createResult._tag === "Failure") {
+        throw new Error(`Failed to create .claude directory: ${createResult.error.message}`);
+      }
+    }
+    let existingContent = null;
+    const fileExistsResult = await pathExists(settingsPath);
+    if (fileExistsResult._tag === "Success" && fileExistsResult.value) {
+      const readResult = await readFile(settingsPath);
+      if (readResult._tag === "Success") {
+        existingContent = readResult.value;
+      }
+    }
+    const hookCommands = await generateHookCommands("claude-code");
+    const settingsResult = processSettings(existingContent, hookCommands);
+    if (settingsResult._tag === "Failure") {
+      throw new Error(`Failed to process settings: ${settingsResult.error.message}`);
+    }
+    const writeResult = await writeFile(settingsPath, settingsResult.value);
+    if (writeResult._tag === "Failure") {
+      throw new Error(`Failed to write settings: ${writeResult.error.message}`);
+    }
+    return {
+      count: 3,
+      message: "Configured session, message, and notification hooks"
+    };
+  },
+  async setupAgents(cwd, options) {
+    const { enhanceAgentContent } = await import("./chunk-5thh3qem.js");
+    const installer = new FileInstaller;
+    const agentsDir = path.join(cwd, this.config.agentDir);
+    const results = await installer.installToDirectory(getAgentsDir(), agentsDir, async (content, sourcePath) => {
+      const transformed = await this.transformAgentContent(content, undefined, sourcePath);
+      const { metadata } = await yamlUtils.extractFrontMatter(transformed);
+      const rules = metadata.rules;
+      const enhanced = await enhanceAgentContent(transformed, rules);
+      return enhanced;
+    }, {
+      ...options,
+      showProgress: false
+    });
+    return { count: results.length };
+  },
+  async setupOutputStyles(_cwd, _options) {
+    return {
+      count: 0,
+      message: "Output styles included in agent files"
+    };
+  },
+  async setupRules(_cwd, _options) {
+    return {
+      count: 0,
+      message: "Rules included in agent files"
+    };
+  },
+  async setupMCP(cwd, options) {
+    const installer = new MCPInstaller(this);
+    const result = await installer.setupMCP({ ...options, quiet: true });
+    if (result.selectedServers.length > 0 && !options.dryRun) {
+      if (this.approveMCPServers) {
+        await this.approveMCPServers(cwd, result.selectedServers);
+      }
+    }
+    return { count: result.selectedServers.length };
+  },
+  async setupSlashCommands(cwd, options) {
+    if (!this.config.slashCommandsDir) {
+      return { count: 0 };
+    }
+    const installer = new FileInstaller;
+    const slashCommandsDir = path.join(cwd, this.config.slashCommandsDir);
+    const results = await installer.installToDirectory(getSlashCommandsDir(), slashCommandsDir, async (content) => {
+      return content;
+    }, {
+      ...options,
+      showProgress: false
+    });
+    return { count: results.length };
+  }
+};
+function convertToClaudeCodeFormat(openCodeMetadata, content, sourcePath) {
+  const agentName = openCodeMetadata.name || pathUtils.extractAgentName(content, openCodeMetadata, sourcePath);
+  const description = openCodeMetadata.description || pathUtils.extractDescription(content);
+  const result = {
+    name: agentName,
+    description
+  };
+  if (openCodeMetadata.model && openCodeMetadata.model !== "inherit") {
+    result.model = openCodeMetadata.model;
+  }
+  return result;
+}
+
+// src/config/targets.ts
+var cachedTargets = null;
+var initializeTargets = () => {
+  if (cachedTargets) {
+    return cachedTargets;
+  }
+  cachedTargets = Object.freeze([opencodeTarget, claudeCodeTarget]);
+  return cachedTargets;
+};
+var getAllTargets = () => initializeTargets();
+var getImplementedTargets = () => getAllTargets().filter((target) => target.isImplemented);
+var getAllTargetIDs = () => getAllTargets().map((target) => target.id);
+var getImplementedTargetIDs = () => getImplementedTargets().map((target) => target.id);
+var getTarget = (id) => {
+  const target = getAllTargets().find((t) => t.id === id);
+  return target ? some(target) : none;
+};
+var getTargetUnsafe = (id) => {
+  const target = getAllTargets().find((t) => t.id === id);
+  if (!target) {
+    throw new Error(`Target not found: ${id}`);
+  }
+  return target;
+};
+var getDefaultTarget = () => {
+  const target = getAllTargets().find((t) => t.isDefault);
+  return target ? some(target) : none;
+};
+var getDefaultTargetUnsafe = () => {
+  const target = getAllTargets().find((t) => t.isDefault);
+  if (!target) {
+    throw new Error("No default target configured");
+  }
+  return target;
+};
+var getTargetsWithMCPSupport = () => getImplementedTargets().filter((target) => !!target.setupMCP);
+var getTargetsWithCommandSupport = () => getImplementedTargets().filter((target) => !!target.executeCommand);
+var isTargetImplemented = (id) => {
+  const target = getAllTargets().find((t) => t.id === id);
+  return target?.isImplemented ?? false;
+};
+var ALL_TARGETS = getAllTargets;
+var IMPLEMENTED_TARGETS = getImplementedTargets;
+export {
+  isTargetImplemented,
+  getTargetsWithMCPSupport,
+  getTargetsWithCommandSupport,
+  getTargetUnsafe,
+  getTarget,
+  getImplementedTargets,
+  getImplementedTargetIDs,
+  getDefaultTargetUnsafe,
+  getDefaultTarget,
+  getAllTargets,
+  getAllTargetIDs,
+  IMPLEMENTED_TARGETS,
+  ALL_TARGETS
+};
+
+export { isSome, getOrElse, getAllTargets, getImplementedTargets, getAllTargetIDs, getImplementedTargetIDs, getTarget, getDefaultTargetUnsafe, getTargetsWithMCPSupport, isTargetImplemented };