@sylphx/flow 1.0.0 → 1.0.1

package/dist/shared/chunk-vmeqwm1c.js

@@ -0,0 +1,204 @@
+import {
+  getAllTargetIDs,
+  getAllTargets,
+  getDefaultTargetUnsafe,
+  getImplementedTargetIDs,
+  getImplementedTargets,
+  getOrElse,
+  getTarget,
+  getTargetsWithMCPSupport,
+  isSome,
+  isTargetImplemented
+} from "./chunk-qk8n91hw.js";
+import {
+  success,
+  tryCatchAsync
+} from "./chunk-nd5fdvaq.js";
+
+// src/utils/settings.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+var SETTINGS_FILE = ".sylphx-flow/settings.json";
+var CURRENT_VERSION = "1.0.0";
+var getSettingsPath = (cwd = process.cwd()) => path.join(cwd, SETTINGS_FILE);
+var settingsExists = async (cwd = process.cwd()) => {
+  try {
+    await fs.access(getSettingsPath(cwd));
+    return true;
+  } catch {
+    return false;
+  }
+};
+var loadSettings = async (cwd = process.cwd()) => {
+  const settingsPath = getSettingsPath(cwd);
+  return tryCatchAsync(async () => {
+    const content = await fs.readFile(settingsPath, "utf8");
+    return JSON.parse(content);
+  }, (error) => {
+    if (error.code === "ENOENT") {
+      return new Error("EMPTY_SETTINGS");
+    }
+    return new Error(`Failed to load settings: ${error.message}`);
+  }).then((result) => {
+    if (result._tag === "Failure" && result.error.message === "EMPTY_SETTINGS") {
+      return success({});
+    }
+    return result;
+  });
+};
+var saveSettings = async (settings, cwd = process.cwd()) => {
+  const settingsPath = getSettingsPath(cwd);
+  return tryCatchAsync(async () => {
+    await fs.mkdir(path.dirname(settingsPath), { recursive: true });
+    const settingsWithVersion = {
+      ...settings,
+      version: settings.version || CURRENT_VERSION
+    };
+    await fs.writeFile(settingsPath, `${JSON.stringify(settingsWithVersion, null, 2)}
+`, "utf8");
+  }, (error) => new Error(`Failed to save settings: ${error.message}`));
+};
+var updateSettings = async (updates, cwd = process.cwd()) => {
+  const currentResult = await loadSettings(cwd);
+  if (currentResult._tag === "Failure") {
+    return currentResult;
+  }
+  const newSettings = { ...currentResult.value, ...updates };
+  return saveSettings(newSettings, cwd);
+};
+var getDefaultTarget = async (cwd = process.cwd()) => {
+  const result = await loadSettings(cwd);
+  return result._tag === "Success" ? result.value.defaultTarget : undefined;
+};
+var setDefaultTarget = async (target, cwd = process.cwd()) => updateSettings({ defaultTarget: target }, cwd);
+
+class ProjectSettings {
+  cwd;
+  constructor(cwd = process.cwd()) {
+    this.cwd = cwd;
+    this.settingsPath = getSettingsPath(cwd);
+  }
+  async load() {
+    const result = await loadSettings(this.cwd);
+    if (result._tag === "Failure") {
+      throw result.error;
+    }
+    return result.value;
+  }
+  async save(settings) {
+    const result = await saveSettings(settings, this.cwd);
+    if (result._tag === "Failure") {
+      throw result.error;
+    }
+  }
+  async update(updates) {
+    const result = await updateSettings(updates, this.cwd);
+    if (result._tag === "Failure") {
+      throw result.error;
+    }
+  }
+  async getDefaultTarget() {
+    return getDefaultTarget(this.cwd);
+  }
+  async setDefaultTarget(target) {
+    const result = await setDefaultTarget(target, this.cwd);
+    if (result._tag === "Failure") {
+      throw result.error;
+    }
+  }
+  async exists() {
+    return settingsExists(this.cwd);
+  }
+}
+var projectSettings = new ProjectSettings;
+
+// src/core/target-manager.ts
+import inquirer from "inquirer";
+function createTargetManager() {
+  const detectTargetFromEnvironment = () => {
+    try {
+      const implementedTargets = getImplementedTargets();
+      const nonDefaultTargets = implementedTargets.filter((target) => !target.isDefault);
+      const defaultTargets = implementedTargets.filter((target) => target.isDefault);
+      for (const target of nonDefaultTargets) {
+        const detected = target.detectFromEnvironment?.();
+        if (detected) {
+          return target.id;
+        }
+      }
+      for (const target of defaultTargets) {
+        const detected = target.detectFromEnvironment?.();
+        if (detected) {
+          return target.id;
+        }
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  };
+  const promptForTargetSelection = async () => {
+    const availableTargets = getImplementedTargetIDs();
+    let defaultTarget = getDefaultTargetUnsafe().id;
+    try {
+      const savedDefaultTarget = await projectSettings.getDefaultTarget();
+      if (savedDefaultTarget && isSome(getTarget(savedDefaultTarget))) {
+        defaultTarget = savedDefaultTarget;
+      }
+    } catch {}
+    const answer = await inquirer.prompt([
+      {
+        type: "list",
+        name: "target",
+        message: "Select target platform:",
+        choices: availableTargets.map((id) => {
+          const targetOption = getTarget(id);
+          const target = getOrElse({ id, name: id })(targetOption);
+          return {
+            name: target.name || id,
+            value: id
+          };
+        }),
+        default: defaultTarget
+      }
+    ]);
+    return answer.target;
+  };
+  const resolveTarget = async (options) => {
+    if (options.target) {
+      if (!isSome(getTarget(options.target))) {
+        throw new Error(`Unknown target: ${options.target}. Available targets: ${getAllTargetIDs().join(", ")}`);
+      }
+      return options.target;
+    }
+    try {
+      const savedDefaultTarget = await projectSettings.getDefaultTarget();
+      if (savedDefaultTarget && isSome(getTarget(savedDefaultTarget))) {
+        return savedDefaultTarget;
+      }
+    } catch (_error) {}
+    const detectedTarget = detectTargetFromEnvironment();
+    if (detectedTarget) {
+      return detectedTarget;
+    }
+    if (options.allowSelection) {
+      return await promptForTargetSelection();
+    }
+    const defaultTarget = getDefaultTargetUnsafe();
+    return defaultTarget.id;
+  };
+  return {
+    getAllTargets: () => getAllTargets(),
+    getImplementedTargets: () => getImplementedTargets(),
+    getTarget: (id) => getTarget(id),
+    promptForTargetSelection,
+    resolveTarget,
+    isTargetImplemented: (targetId) => isTargetImplemented(targetId),
+    getTargetsWithMCPSupport: () => getTargetsWithMCPSupport(),
+    getImplementedTargetIDs: () => getImplementedTargetIDs(),
+    getAllTargetIDs: () => getAllTargetIDs()
+  };
+}
+var targetManager = createTargetManager();
+
+export { projectSettings, targetManager };

package/dist/shared/chunk-x66eh37x.js

@@ -0,0 +1,137 @@
+import {
+  CONFIG_DIR,
+  USER_SETTINGS_FILE,
+  getProjectLocalSettingsFile,
+  getProjectSettingsFile
+} from "./chunk-7eq34c42.js";
+import"./chunk-5j4w74t6.js";
+
+// src/services/config-service.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+class ConfigService {
+  static async loadConfiguration(cwd = process.cwd()) {
+    const userSettings = await this.loadHomeSettings();
+    const projectSettings = await this.loadProjectSettings(cwd);
+    const localSettings = await this.loadLocalSettings(cwd);
+    const choices = {
+      provider: localSettings.provider || userSettings.defaultProvider,
+      agent: localSettings.agent || projectSettings.defaultAgent || userSettings.defaultAgent
+    };
+    return {
+      user: userSettings,
+      project: projectSettings,
+      choices
+    };
+  }
+  static async loadSettings(cwd = process.cwd()) {
+    const config = await this.loadConfiguration(cwd);
+    return {
+      ...config.user,
+      ...config.project,
+      ...config.choices
+    };
+  }
+  static async loadHomeSettings() {
+    try {
+      const content = await fs.readFile(USER_SETTINGS_FILE, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return {};
+    }
+  }
+  static async saveHomeSettings(settings) {
+    await fs.mkdir(USER_SETTINGS_FILE.replace("/settings.json", ""), { recursive: true });
+    const existing = await this.loadHomeSettings();
+    const merged = { ...existing, ...settings };
+    await fs.writeFile(USER_SETTINGS_FILE, JSON.stringify(merged, null, 2) + `
+`);
+  }
+  static async hasInitialSetup() {
+    const userSettings = await this.loadHomeSettings();
+    return !!(userSettings.hasCompletedSetup || userSettings.apiKeys && Object.keys(userSettings.apiKeys).length > 0);
+  }
+  static getAvailableProviders(userSettings) {
+    const providers = ["default"];
+    if (userSettings.apiKeys?.kimi)
+      providers.push("kimi");
+    if (userSettings.apiKeys?.["z.ai"])
+      providers.push("z.ai");
+    return providers;
+  }
+  static async loadProjectSettings(cwd = process.cwd()) {
+    try {
+      const configPath = getProjectSettingsFile(cwd);
+      const content = await fs.readFile(configPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return {};
+    }
+  }
+  static async saveProjectSettings(settings, cwd = process.cwd()) {
+    const configDir = path.join(cwd, CONFIG_DIR);
+    await fs.mkdir(configDir, { recursive: true });
+    const existing = await this.loadProjectSettings(cwd);
+    const merged = { ...existing, ...settings };
+    const configPath = getProjectSettingsFile(cwd);
+    await fs.writeFile(configPath, JSON.stringify(merged, null, 2) + `
+`);
+  }
+  static async loadLocalSettings(cwd = process.cwd()) {
+    try {
+      const configPath = getProjectLocalSettingsFile(cwd);
+      const content = await fs.readFile(configPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return {};
+    }
+  }
+  static async saveLocalSettings(settings, cwd = process.cwd()) {
+    const configDir = path.join(cwd, CONFIG_DIR);
+    await fs.mkdir(configDir, { recursive: true });
+    const configPath = getProjectLocalSettingsFile(cwd);
+    await fs.writeFile(configPath, JSON.stringify(settings, null, 2) + `
+`);
+  }
+  static async saveClaudeConfig(projectConfig, userConfig, cwd = process.cwd()) {
+    if (userConfig.claudeApiKey || userConfig.claudeProvider || userConfig.claudeProviderConfig) {
+      await this.saveHomeSettings(userConfig);
+    }
+    await this.saveProjectSettings(projectConfig, cwd);
+    await this.addGitignore(cwd);
+  }
+  static async addGitignore(cwd) {
+    const gitignorePath = path.join(cwd, ".gitignore");
+    const patterns = [
+      "",
+      "# Sylphx Flow - local settings (never commit)",
+      ".sylphx-flow/*.local.json"
+    ];
+    try {
+      const content = await fs.readFile(gitignorePath, "utf-8");
+      if (!content.includes(".sylphx-flow/*.local.json")) {
+        await fs.appendFile(gitignorePath, patterns.join(`
+`) + `
+`);
+      }
+    } catch {
+      await fs.writeFile(gitignorePath, patterns.join(`
+`).trim() + `
+`);
+    }
+  }
+  static async isInitialized(cwd = process.cwd()) {
+    try {
+      const configDir = path.join(cwd, CONFIG_DIR);
+      await fs.access(configDir);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+export {
+  ConfigService
+};
+
+export { ConfigService };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sylphx/flow",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "AI-powered development workflow automation with autonomous loop mode and smart configuration",
   "type": "module",
   "bin": {
@@ -13,7 +13,8 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "type-check": "tsc --noEmit",
-    "clean": "rm -rf dist"
+    "clean": "rm -rf dist",
+    "prepublishOnly": "bun run build"
   },
   "dependencies": {
     "commander": "^14.0.2",