@sylphx/flow 1.0.0 → 1.0.1

package/dist/shared/chunk-t16rfxh0.js

@@ -0,0 +1,61 @@
+import {
+  pathSecurity
+} from "./chunk-hpkhykhq.js";
+
+// src/utils/paths.ts
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function findPackageRoot(context) {
+  const __filename2 = fileURLToPath(import.meta.url);
+  let currentDir = path.dirname(__filename2);
+  for (let i = 0;i < 10; i++) {
+    const packageJsonPath = path.join(currentDir, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      return currentDir;
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir)
+      break;
+    currentDir = parentDir;
+  }
+  const errorMsg = context ? `Cannot find package.json - ${context} location unknown` : "Cannot find package.json";
+  throw new Error(errorMsg);
+}
+var PACKAGE_ROOT = findPackageRoot();
+var MONOREPO_ROOT = path.join(PACKAGE_ROOT, "..", "..");
+var ASSETS_ROOT = fs.existsSync(path.join(MONOREPO_ROOT, "assets")) ? path.join(MONOREPO_ROOT, "assets") : path.join(PACKAGE_ROOT, "assets");
+function getAgentsDir() {
+  return path.join(ASSETS_ROOT, "agents");
+}
+function getRulesDir() {
+  return path.join(ASSETS_ROOT, "rules");
+}
+function getKnowledgeDir() {
+  return path.join(ASSETS_ROOT, "knowledge");
+}
+function getOutputStylesDir() {
+  return path.join(ASSETS_ROOT, "output-styles");
+}
+function getSlashCommandsDir() {
+  return path.join(ASSETS_ROOT, "slash-commands");
+}
+function getRuleFile(filename) {
+  if (!filename || typeof filename !== "string") {
+    throw new Error("Filename must be a non-empty string");
+  }
+  if (filename.includes("..") || filename.includes("/") || filename.includes("\\")) {
+    throw new Error(`Invalid filename: ${filename}. Path traversal not allowed.`);
+  }
+  if (!/^[a-zA-Z0-9._-]+$/.test(filename)) {
+    throw new Error(`Filename contains invalid characters: ${filename}`);
+  }
+  const rulesDir = getRulesDir();
+  const filePath = pathSecurity.safeJoin(rulesDir, filename);
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Rule file not found: ${filename} (looked in ${rulesDir})`);
+  }
+  return filePath;
+}
+
+export { getAgentsDir, getRulesDir, getKnowledgeDir, getOutputStylesDir, getSlashCommandsDir, getRuleFile };

package/dist/shared/chunk-t4fbfa5v.js

@@ -0,0 +1,19 @@
+// src/core/functional/error-types.ts
+var configError = (message, options) => ({
+  kind: "ConfigError",
+  message,
+  configKey: options?.configKey,
+  configPath: options?.configPath,
+  context: options?.context,
+  cause: options?.cause
+});
+var fileSystemError = (message, path, operation, options) => ({
+  kind: "FileSystemError",
+  message,
+  path,
+  operation,
+  context: options?.context,
+  cause: options?.cause
+});
+
+export { configError, fileSystemError };

package/dist/shared/chunk-t77h86w6.js

@@ -0,0 +1,276 @@
+import {
+  ConfigService
+} from "./chunk-x66eh37x.js";
+import {
+  __require,
+  __toESM
+} from "./chunk-5j4w74t6.js";
+
+// src/core/state-detector.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path.dirname(__filename2);
+
+class StateDetector {
+  projectPath;
+  constructor(projectPath = process.cwd()) {
+    this.projectPath = projectPath;
+  }
+  async detect() {
+    const state = {
+      initialized: false,
+      version: null,
+      latestVersion: await this.getLatestFlowVersion(),
+      target: null,
+      targetVersion: null,
+      targetLatestVersion: null,
+      components: {
+        agents: { installed: false, count: 0, version: null },
+        rules: { installed: false, count: 0, version: null },
+        hooks: { installed: false, version: null },
+        mcp: { installed: false, serverCount: 0, version: null },
+        outputStyles: { installed: false, version: null },
+        slashCommands: { installed: false, count: 0, version: null }
+      },
+      corrupted: false,
+      outdated: false,
+      lastUpdated: null
+    };
+    try {
+      state.initialized = await ConfigService.isInitialized(this.projectPath);
+      if (!state.initialized) {
+        return state;
+      }
+      const config = await ConfigService.loadProjectSettings(this.projectPath);
+      state.version = config.version || null;
+      state.target = config.target || null;
+      state.lastUpdated = config.lastUpdated ? new Date(config.lastUpdated) : null;
+      if (state.version && state.latestVersion) {
+        state.outdated = this.isVersionOutdated(state.version, state.latestVersion);
+      }
+      if (state.target === "opencode") {
+        await this.checkComponent("agents", ".opencode/agent", "*.md", state);
+        await this.checkFileComponent("rules", "AGENTS.md", state);
+        state.components.hooks.installed = false;
+        state.components.outputStyles.installed = await this.checkOutputStylesInAGENTS();
+        await this.checkComponent("slashCommands", ".opencode/command", "*.md", state);
+      } else {
+        await this.checkComponent("agents", ".claude/agents", "*.md", state);
+        await this.checkComponent("rules", ".claude/rules", "*.md", state);
+        await this.checkComponent("hooks", ".claude/hooks", "*.js", state);
+        await this.checkComponent("outputStyles", ".claude/output-styles", "*.md", state);
+        await this.checkComponent("slashCommands", ".claude/commands", "*.md", state);
+      }
+      const mcpConfig = await this.checkMCPConfig(state.target);
+      state.components.mcp.installed = mcpConfig.exists;
+      state.components.mcp.serverCount = mcpConfig.serverCount;
+      state.components.mcp.version = mcpConfig.version;
+      if (state.target) {
+        const targetInfo = await this.checkTargetVersion(state.target);
+        state.targetVersion = targetInfo.version;
+        state.targetLatestVersion = targetInfo.latestVersion;
+      }
+      state.corrupted = await this.checkCorruption(state);
+    } catch (error) {
+      state.corrupted = true;
+    }
+    return state;
+  }
+  recommendAction(state) {
+    if (!state.initialized) {
+      return "FULL_INIT";
+    }
+    if (state.corrupted) {
+      return "REPAIR";
+    }
+    if (state.outdated && state.version !== state.latestVersion) {
+      return "UPGRADE";
+    }
+    if (state.targetVersion && state.targetLatestVersion && this.isVersionOutdated(state.targetVersion, state.targetLatestVersion)) {
+      return "UPGRADE_TARGET";
+    }
+    return "RUN_ONLY";
+  }
+  async explainState(state) {
+    const explanations = [];
+    if (!state.initialized) {
+      explanations.push("Project not initialized yet");
+      explanations.push("Run `bun dev:flow` to start initialization");
+      return explanations;
+    }
+    if (state.corrupted) {
+      explanations.push("Configuration corruption detected");
+      explanations.push("Run `bun dev:flow --clean` to repair");
+      return explanations;
+    }
+    if (state.outdated) {
+      explanations.push(`Flow version outdated: ${state.version} → ${state.latestVersion}`);
+      explanations.push("Run `bun dev:flow upgrade` to upgrade");
+    }
+    if (state.targetVersion && state.targetLatestVersion && this.isVersionOutdated(state.targetVersion, state.targetLatestVersion)) {
+      explanations.push(`${state.target} update available`);
+      explanations.push(`Run \`bun dev:flow upgrade-target\` to upgrade`);
+    }
+    Object.entries(state.components).forEach(([name, component]) => {
+      if (!component.installed) {
+        explanations.push(`Missing ${name}`);
+      }
+    });
+    if (explanations.length === 0) {
+      explanations.push("Project status is normal");
+      explanations.push("Run `bun dev:flow` to start Claude Code");
+    }
+    return explanations;
+  }
+  async getLatestFlowVersion() {
+    try {
+      const packagePath = path.join(__dirname2, "..", "..", "package.json");
+      const packageJson = JSON.parse(await fs.readFile(packagePath, "utf-8"));
+      return packageJson.version || null;
+    } catch {
+      return null;
+    }
+  }
+  async checkComponent(componentName, componentPath, pattern, state) {
+    try {
+      const fullPath = path.join(this.projectPath, componentPath);
+      const exists = await fs.access(fullPath).then(() => true).catch(() => false);
+      state.components[componentName].installed = exists;
+      if (exists) {
+        const files = await fs.readdir(fullPath).catch(() => []);
+        const count = pattern === "*.js" ? files.filter((f) => f.endsWith(".js")).length : pattern === "*.md" ? files.filter((f) => f.endsWith(".md")).length : files.length;
+        if (componentName === "agents" || componentName === "slashCommands" || componentName === "rules") {
+          state.components[componentName].count = count;
+        }
+        const versionPath = path.join(fullPath, ".version");
+        const versionExists = await fs.access(versionPath).then(() => true).catch(() => false);
+        if (versionExists) {
+          state.components[componentName].version = await fs.readFile(versionPath, "utf-8");
+        }
+      }
+    } catch {
+      state.components[componentName].installed = false;
+    }
+  }
+  async checkFileComponent(componentName, filePath, state) {
+    try {
+      const fullPath = path.join(this.projectPath, filePath);
+      const exists = await fs.access(fullPath).then(() => true).catch(() => false);
+      state.components[componentName].installed = exists;
+      if (exists && componentName === "rules") {
+        state.components[componentName].count = 1;
+      }
+    } catch {
+      state.components[componentName].installed = false;
+    }
+  }
+  async checkOutputStylesInAGENTS() {
+    try {
+      const agentsPath = path.join(this.projectPath, "AGENTS.md");
+      const exists = await fs.access(agentsPath).then(() => true).catch(() => false);
+      if (!exists) {
+        return false;
+      }
+      const content = await fs.readFile(agentsPath, "utf-8");
+      return content.includes("# Output Styles");
+    } catch {
+      return false;
+    }
+  }
+  async checkMCPConfig(target) {
+    try {
+      let mcpPath;
+      let serversKey;
+      if (target === "opencode") {
+        mcpPath = path.join(this.projectPath, "opencode.jsonc");
+        serversKey = "mcp";
+      } else {
+        mcpPath = path.join(this.projectPath, ".mcp.json");
+        serversKey = "mcpServers";
+      }
+      const exists = await fs.access(mcpPath).then(() => true).catch(() => false);
+      if (!exists) {
+        return { exists: false, serverCount: 0, version: null };
+      }
+      let content;
+      if (target === "opencode") {
+        const { fileUtils } = await import("./chunk-hpkhykhq.js");
+        const { opencodeTarget } = await import("./chunk-cjd3mk4c.js");
+        content = await fileUtils.readConfig(opencodeTarget.config, this.projectPath);
+      } else {
+        content = JSON.parse(await fs.readFile(mcpPath, "utf-8"));
+      }
+      const servers = content[serversKey] || {};
+      return {
+        exists: true,
+        serverCount: Object.keys(servers).length,
+        version: content.version || null
+      };
+    } catch {
+      return { exists: false, serverCount: 0, version: null };
+    }
+  }
+  async checkTargetVersion(target) {
+    try {
+      if (target === "claude-code") {
+        const { exec } = await import("node:child_process");
+        const { promisify } = await import("node:util");
+        const execAsync = promisify(exec);
+        try {
+          const { stdout } = await execAsync("claude --version");
+          const match = stdout.match(/v?(\d+\.\d+\.\d+)/);
+          return {
+            version: match ? match[1] : null,
+            latestVersion: await this.getLatestClaudeVersion()
+          };
+        } catch {
+          return { version: null, latestVersion: null };
+        }
+      }
+      return { version: null, latestVersion: null };
+    } catch {
+      return { version: null, latestVersion: null };
+    }
+  }
+  async getLatestClaudeVersion() {
+    try {
+      const { exec } = await import("node:child_process");
+      const { promisify } = await import("node:util");
+      const execAsync = promisify(exec);
+      const { stdout } = await execAsync("npm view @anthropic-ai/claude-code version");
+      return stdout.trim();
+    } catch {
+      return null;
+    }
+  }
+  async checkCorruption(state) {
+    if (state.initialized && !state.target) {
+      return true;
+    }
+    if (state.initialized && state.target === "claude-code" && !state.components.agents.installed) {
+      return true;
+    }
+    return false;
+  }
+  isVersionOutdated(current, latest) {
+    try {
+      return this.compareVersions(current, latest) < 0;
+    } catch {
+      return false;
+    }
+  }
+  compareVersions(v1, v2) {
+    const parts1 = v1.split(".").map(Number);
+    const parts2 = v2.split(".").map(Number);
+    for (let i = 0;i < Math.min(parts1.length, parts2.length); i++) {
+      if (parts1[i] !== parts2[i]) {
+        return parts1[i] - parts2[i];
+      }
+    }
+    return parts1.length - parts2.length;
+  }
+}
+
+export { StateDetector };

package/dist/shared/chunk-v0ez4aef.js

@@ -0,0 +1,71 @@
+import {
+  installComponents,
+  previewDryRun,
+  selectAndValidateTarget
+} from "./chunk-6g9xy73m.js";
+import"./chunk-x66eh37x.js";
+import"./chunk-7eq34c42.js";
+import"./chunk-vmeqwm1c.js";
+import"./chunk-qk8n91hw.js";
+import"./chunk-nd5fdvaq.js";
+import"./chunk-cjd3mk4c.js";
+import"./chunk-t16rfxh0.js";
+import"./chunk-hpkhykhq.js";
+import"./chunk-5j4w74t6.js";
+
+// src/commands/init-command.ts
+import boxen from "boxen";
+import chalk from "chalk";
+import gradient from "gradient-string";
+async function runInit(options) {
+  const title = `
+███████╗██╗   ██╗██╗     ██████╗ ██╗  ██╗██╗  ██╗    ███████╗██╗      ██████╗ ██╗    ██╗
+██╔════╝╚██╗ ██╔╝██║     ██╔══██╗██║  ██║╚██╗██╔╝    ██╔════╝██║     ██╔═══██╗██║    ██║
+███████╗ ╚████╔╝ ██║     ██████╔╝███████║ ╚███╔╝     █████╗  ██║     ██║   ██║██║ █╗ ██║
+╚════██║  ╚██╔╝  ██║     ██╔═══╝ ██╔══██║ ██╔██╗     ██╔══╝  ██║     ██║   ██║██║███╗██║
+███████║   ██║   ███████╗██║     ██║  ██║██╔╝ ██╗    ██║     ███████╗╚██████╔╝╚███╔███╔╝
+╚══════╝   ╚═╝   ╚══════╝╚═╝     ╚═╝  ╚═╝╚═╝  ╚═╝    ╚═╝     ╚══════╝ ╚═════╝  ╚══╝╚══╝
+`;
+  console.log(gradient(["cyan", "blue"])(title));
+  console.log(chalk.dim.cyan(`                          Project Initialization
+`));
+  const targetId = await selectAndValidateTarget(options);
+  if (options.dryRun) {
+    console.log(boxen(chalk.yellow("⚠ Dry Run Mode") + chalk.dim(`
+No changes will be made to your project`), {
+      padding: 1,
+      margin: { top: 0, bottom: 1, left: 0, right: 0 },
+      borderStyle: "round",
+      borderColor: "yellow"
+    }));
+    await previewDryRun(targetId, options);
+    console.log(`
+` + boxen(chalk.green.bold("✓ Dry run complete"), {
+      padding: { top: 0, bottom: 0, left: 2, right: 2 },
+      margin: 0,
+      borderStyle: "round",
+      borderColor: "green"
+    }) + `
+`);
+    return;
+  }
+  console.log(chalk.cyan.bold(`
+━━━ Installing Core Components ━━━
+`));
+  const result = await installComponents(targetId, options);
+  console.log(`
+` + boxen(chalk.green.bold("✓ Setup complete!") + `
+
+` + chalk.dim(`Target: ${result.targetName}`) + `
+
+` + chalk.cyan("Ready to code with Sylphx Flow"), {
+    padding: 1,
+    margin: 0,
+    borderStyle: "round",
+    borderColor: "green"
+  }) + `
+`);
+}
+export {
+  runInit
+};