ralph-mem 0.1.0

package/dist/skills/ralph-config.js

@@ -0,0 +1,404 @@
+import {
+  DEFAULT_CONFIG,
+  dump,
+  getProjectConfigPath,
+  loadConfig,
+  loadYamlConfig
+} from "../chunk-c3a91ngd.js";
+import"../chunk-w40c0y00.js";
+import"../chunk-ns0dgdnb.js";
+
+// src/skills/ralph-config.ts
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+var VALID_CONFIG_KEYS = new Set([
+  "ralph.max_iterations",
+  "ralph.max_duration_ms",
+  "ralph.no_progress_threshold",
+  "ralph.context_budget",
+  "ralph.cooldown_ms",
+  "memory.auto_inject",
+  "memory.max_inject_tokens",
+  "memory.retention_days",
+  "search.fts_first",
+  "search.embedding_fallback",
+  "search.default_limit",
+  "privacy.exclude_patterns",
+  "logging.level",
+  "logging.file"
+]);
+var CONFIG_KEY_TYPES = {
+  "ralph.max_iterations": "number",
+  "ralph.max_duration_ms": "number",
+  "ralph.no_progress_threshold": "number",
+  "ralph.context_budget": "number",
+  "ralph.cooldown_ms": "number",
+  "memory.auto_inject": "boolean",
+  "memory.max_inject_tokens": "number",
+  "memory.retention_days": "number",
+  "search.fts_first": "boolean",
+  "search.embedding_fallback": "boolean",
+  "search.default_limit": "number",
+  "privacy.exclude_patterns": "array",
+  "logging.level": "string",
+  "logging.file": "boolean"
+};
+function parseConfigArgs(argsString) {
+  const args = {};
+  const trimmed = argsString.trim();
+  if (!trimmed) {
+    return args;
+  }
+  const tokens = [];
+  let current = "";
+  let inQuotes = false;
+  let quoteChar = "";
+  for (const char of trimmed) {
+    if ((char === '"' || char === "'") && !inQuotes) {
+      inQuotes = true;
+      quoteChar = char;
+    } else if (char === quoteChar && inQuotes) {
+      inQuotes = false;
+      quoteChar = "";
+    } else if (char === " " && !inQuotes) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+    } else {
+      current += char;
+    }
+  }
+  if (current) {
+    tokens.push(current);
+  }
+  if (tokens[0] === "set" && tokens.length >= 3) {
+    args.subcommand = "set";
+    args.key = tokens[1];
+    args.value = tokens.slice(2).join(" ");
+  } else if (tokens[0] === "init") {
+    args.subcommand = "init";
+  } else if (tokens[0] === "get" && tokens.length >= 2) {
+    args.subcommand = "get";
+    args.key = tokens[1];
+  } else if (tokens[0] && !tokens[0].startsWith("-")) {
+    args.subcommand = "get";
+    args.key = tokens[0];
+  }
+  return args;
+}
+function isValidConfigKey(key) {
+  return VALID_CONFIG_KEYS.has(key);
+}
+function getConfigValue(config, key) {
+  const [section, prop] = key.split(".");
+  if (!section || !prop)
+    return;
+  const sectionObj = config[section];
+  if (!sectionObj || typeof sectionObj !== "object")
+    return;
+  return sectionObj[prop];
+}
+function setConfigValue(config, key, value) {
+  const [section, prop] = key.split(".");
+  if (!section || !prop)
+    return;
+  if (!config[section]) {
+    config[section] = {};
+  }
+  config[section][prop] = value;
+}
+function parseConfigValue(key, valueStr) {
+  const expectedType = CONFIG_KEY_TYPES[key];
+  switch (expectedType) {
+    case "number": {
+      const num = Number(valueStr);
+      if (Number.isNaN(num)) {
+        throw new Error(`값이 숫자여야 합니다: ${key}`);
+      }
+      return num;
+    }
+    case "boolean": {
+      const lower = valueStr.toLowerCase();
+      if (lower === "true" || lower === "1" || lower === "yes") {
+        return true;
+      }
+      if (lower === "false" || lower === "0" || lower === "no") {
+        return false;
+      }
+      throw new Error(`값이 boolean이어야 합니다 (true/false): ${key}`);
+    }
+    case "array": {
+      try {
+        const parsed = JSON.parse(valueStr);
+        if (Array.isArray(parsed)) {
+          return parsed;
+        }
+      } catch {}
+      return valueStr.split(",").map((s) => s.trim());
+    }
+    default:
+      return valueStr;
+  }
+}
+function validateConfigValue(key, value) {
+  const expectedType = CONFIG_KEY_TYPES[key];
+  switch (expectedType) {
+    case "number":
+      return typeof value === "number" && !Number.isNaN(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "array":
+      return Array.isArray(value);
+    case "string":
+      return typeof value === "string";
+    default:
+      return true;
+  }
+}
+function formatConfig(config, configPath) {
+  const lines = [];
+  lines.push(`⚙️ Ralph 설정
+`);
+  lines.push("ralph:");
+  lines.push(`  max_iterations: ${config.ralph.max_iterations}`);
+  lines.push(`  max_duration_ms: ${config.ralph.max_duration_ms}`);
+  lines.push(`  no_progress_threshold: ${config.ralph.no_progress_threshold}`);
+  lines.push(`  context_budget: ${config.ralph.context_budget}`);
+  lines.push(`  cooldown_ms: ${config.ralph.cooldown_ms}`);
+  if (config.ralph.success_criteria.length > 0) {
+    lines.push("  success_criteria:");
+    for (const c of config.ralph.success_criteria) {
+      lines.push(`    - type: ${c.type}`);
+      if (c.command)
+        lines.push(`      command: ${c.command}`);
+    }
+  }
+  lines.push("");
+  lines.push("memory:");
+  lines.push(`  auto_inject: ${config.memory.auto_inject}`);
+  lines.push(`  max_inject_tokens: ${config.memory.max_inject_tokens}`);
+  lines.push(`  retention_days: ${config.memory.retention_days}`);
+  lines.push("");
+  lines.push("search:");
+  lines.push(`  fts_first: ${config.search.fts_first}`);
+  lines.push(`  embedding_fallback: ${config.search.embedding_fallback}`);
+  lines.push(`  default_limit: ${config.search.default_limit}`);
+  lines.push("");
+  lines.push("privacy:");
+  lines.push(`  exclude_patterns: [${config.privacy.exclude_patterns.join(", ")}]`);
+  lines.push("");
+  lines.push("logging:");
+  lines.push(`  level: ${config.logging.level}`);
+  lines.push(`  file: ${config.logging.file}`);
+  lines.push("");
+  if (configPath && existsSync(configPath)) {
+    lines.push(`설정 파일: ${configPath}`);
+  } else {
+    lines.push("설정 파일: (기본값 사용)");
+  }
+  return lines.join(`
+`);
+}
+function formatConfigValue(key, value) {
+  if (Array.isArray(value)) {
+    return `${key}: [${value.join(", ")}]`;
+  }
+  return `${key}: ${value}`;
+}
+function saveConfig(projectPath, config) {
+  const configPath = getProjectConfigPath(projectPath);
+  const configDir = dirname(configPath);
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+  const yaml = dump(config, { indent: 2 });
+  writeFileSync(configPath, yaml, "utf-8");
+}
+function createInitialConfig(options) {
+  const ralph = { ...DEFAULT_CONFIG.ralph };
+  if (options.testCommand) {
+    ralph.success_criteria = [
+      {
+        type: "test_pass",
+        command: options.testCommand
+      }
+    ];
+  }
+  return { ralph };
+}
+function detectProjectType(projectPath) {
+  if (existsSync(join(projectPath, "package.json"))) {
+    return "node";
+  }
+  if (existsSync(join(projectPath, "pyproject.toml")) || existsSync(join(projectPath, "setup.py")) || existsSync(join(projectPath, "requirements.txt"))) {
+    return "python";
+  }
+  if (existsSync(join(projectPath, "go.mod"))) {
+    return "go";
+  }
+  if (existsSync(join(projectPath, "Cargo.toml"))) {
+    return "rust";
+  }
+  return "other";
+}
+function getSuggestedCommands(projectType) {
+  switch (projectType) {
+    case "node":
+      return { test: "npm test", build: "npm run build" };
+    case "python":
+      return { test: "pytest", build: "pip install -e ." };
+    case "go":
+      return { test: "go test ./...", build: "go build" };
+    case "rust":
+      return { test: "cargo test", build: "cargo build" };
+    default:
+      return { test: "make test", build: "make build" };
+  }
+}
+function createRalphConfigSkill(context) {
+  const { projectPath } = context;
+  return {
+    name: "/ralph config",
+    show() {
+      const config = loadConfig(projectPath);
+      const configPath = getProjectConfigPath(projectPath);
+      const message = formatConfig(config, configPath);
+      return {
+        success: true,
+        message,
+        config
+      };
+    },
+    get(key) {
+      if (!isValidConfigKey(key)) {
+        return {
+          success: false,
+          message: "",
+          error: `잘못된 설정 키: ${key}`
+        };
+      }
+      const config = loadConfig(projectPath);
+      const value = getConfigValue(config, key);
+      return {
+        success: true,
+        message: formatConfigValue(key, value)
+      };
+    },
+    set(key, valueStr) {
+      if (!isValidConfigKey(key)) {
+        return {
+          success: false,
+          message: "",
+          error: `잘못된 설정 키: ${key}`
+        };
+      }
+      let value;
+      try {
+        value = parseConfigValue(key, valueStr);
+      } catch (error) {
+        return {
+          success: false,
+          message: "",
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+      if (!validateConfigValue(key, value)) {
+        return {
+          success: false,
+          message: "",
+          error: `타입이 맞지 않습니다: ${key}는 ${CONFIG_KEY_TYPES[key]}이어야 합니다`
+        };
+      }
+      const configPath = getProjectConfigPath(projectPath);
+      const projectConfig = loadYamlConfig(configPath);
+      setConfigValue(projectConfig, key, value);
+      saveConfig(projectPath, projectConfig);
+      return {
+        success: true,
+        message: `✅ 설정 저장됨: ${formatConfigValue(key, value)}`
+      };
+    },
+    init() {
+      const configPath = getProjectConfigPath(projectPath);
+      if (existsSync(configPath)) {
+        return {
+          success: false,
+          message: "",
+          error: `설정 파일이 이미 존재합니다: ${configPath}`
+        };
+      }
+      const projectType = detectProjectType(projectPath);
+      const commands = getSuggestedCommands(projectType);
+      const config = createInitialConfig({
+        projectType,
+        testCommand: commands.test
+      });
+      saveConfig(projectPath, config);
+      return {
+        success: true,
+        message: `✅ 설정 파일 생성됨: ${configPath}
+
+프로젝트 유형: ${projectType}
+테스트 명령: ${commands.test}
+빌드 명령: ${commands.build}
+
+설정 수정: /ralph config set <key> <value>
+설정 조회: /ralph config`
+      };
+    },
+    execute(args) {
+      if (!args.subcommand) {
+        return this.show();
+      }
+      switch (args.subcommand) {
+        case "get":
+          if (!args.key) {
+            return this.show();
+          }
+          return this.get(args.key);
+        case "set":
+          if (!args.key || args.value === undefined) {
+            return {
+              success: false,
+              message: "",
+              error: "사용법: /ralph config set <key> <value>"
+            };
+          }
+          return this.set(args.key, args.value);
+        case "init":
+          return this.init();
+        default:
+          return this.show();
+      }
+    },
+    parseArgs(argsString) {
+      return parseConfigArgs(argsString);
+    }
+  };
+}
+async function executeRalphConfig(argsString, context) {
+  const skill = createRalphConfigSkill(context);
+  const args = skill.parseArgs(argsString);
+  const result = skill.execute(args);
+  if (result.error) {
+    return `❌ ${result.error}`;
+  }
+  return result.message;
+}
+export {
+  validateConfigValue,
+  setConfigValue,
+  saveConfig,
+  parseConfigValue,
+  parseConfigArgs,
+  isValidConfigKey,
+  getSuggestedCommands,
+  getConfigValue,
+  formatConfigValue,
+  formatConfig,
+  executeRalphConfig,
+  detectProjectType,
+  createRalphConfigSkill,
+  createInitialConfig
+};