@sylphx/flow 0.2.13 → 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,115 +1,67 @@
 {
   "name": "@sylphx/flow",
-  "version": "0.2.13",
-  "description": "Sylphx Flow - Type-safe development flow for modern web development",
+  "version": "1.0.1",
+  "description": "AI-powered development workflow automation with autonomous loop mode and smart configuration",
   "type": "module",
-  "main": "dist/index.js",
   "bin": {
-    "sylphx-flow": "dist/index.js"
+    "sylphx-flow": "./dist/index.js"
   },
-  "files": [
-    "dist",
-    "drizzle",
-    "assets",
-    "README.md",
-    "LICENSE"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/sylphxltd/flow.git"
-  },
-  "keywords": [
-    "development",
-    "flow",
-    "guidelines",
-    "typescript",
-    "nextjs",
-    "sveltekit",
-    "react",
-    "flutter",
-    "type-safe",
-    "mcp",
-    "ai-agents",
-    "github-installation"
-  ],
-  "author": "sylphxltd",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/sylphxltd/flow/issues"
-  },
-  "homepage": "https://github.com/sylphxltd/flow#readme",
   "scripts": {
-    "build": "bun run build.ts",
-    "prepare": "bun run build.ts",
+    "build": "bunup",
     "dev": "bun src/index.ts",
     "start": "bun dist/index.js",
-    "start:node": "node dist/index.js",
-    "clean": "rm -rf dist",
-    "clean:all": "rm -rf dist node_modules/.cache",
-    "lint": "biome check .",
-    "lint:fix": "biome check --write .",
-    "format": "biome format --write .",
-    "format:check": "biome format .",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "type-check": "tsc --noEmit",
-    "test": "vitest",
-    "test:ui": "vitest --ui",
-    "test:chat": "bun src/test-chat.ts",
-    "test:run": "vitest run",
-    "test:coverage": "vitest run --coverage"
-  },
-  "engines": {
-    "node": ">=18.0.0"
+    "clean": "rm -rf dist",
+    "prepublishOnly": "bun run build"
   },
-  "packageManager": "bun@1.3.1",
   "dependencies": {
-    "@ai-sdk/anthropic": "^2.0.40",
-    "@ai-sdk/google": "^2.0.26",
-    "@ai-sdk/openai": "^2.0.59",
-    "@ai-sdk/openai-compatible": "^1.0.25",
-    "@huggingface/transformers": "^3.7.6",
-    "@jescalan/ink-markdown": "^2.0.0",
-    "@lancedb/lancedb": "^0.22.2",
-    "@libsql/client": "^0.15.15",
-    "@modelcontextprotocol/sdk": "^1.20.2",
-    "@openrouter/ai-sdk-provider": "^1.2.0",
-    "ai": "^5.0.86",
-    "ai-sdk-provider-claude-code": "^2.1.0",
-    "apache-arrow": "^21.1.0",
-    "boxen": "^8.0.1",
-    "chalk": "^5.6.2",
-    "chokidar": "^4.0.3",
-    "cli-progress": "^3.12.0",
-    "cli-table3": "^0.6.5",
     "commander": "^14.0.2",
-    "drizzle-orm": "^0.44.7",
+    "chalk": "^5.6.2",
+    "boxen": "^8.0.1",
     "gradient-string": "^3.0.0",
-    "gray-matter": "^4.0.3",
-    "ignore": "^7.0.5",
-    "immer": "^10.2.0",
-    "ink": "^6.4.0",
-    "ink-select-input": "^6.2.0",
-    "ink-text-input": "^6.0.0",
-    "inquirer": "^12.10.0",
     "ora": "^9.0.0",
-    "react": "^19.2.0",
-    "react-devtools-core": "^7.0.1",
+    "inquirer": "^12.10.0",
+    "gray-matter": "^4.0.3",
     "yaml": "^2.8.1",
     "zod": "^4.1.12",
-    "zustand": "^5.0.8"
+    "debug": "^4.4.3"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.3.2",
-    "@types/bun": "^1.3.1",
     "@types/node": "^24.9.2",
-    "@vitest/coverage-v8": "^4.0.6",
-    "@vitest/ui": "^4.0.6",
-    "drizzle-kit": "^0.31.6",
-    "esbuild": "^0.25.11",
-    "jscpd": "^4.0.5",
-    "madge": "^8.0.0",
-    "ts-prune": "^0.10.3",
-    "tsx": "^4.20.6",
     "typescript": "^5.9.3",
     "vitest": "^4.0.6"
-  }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LOOP_MODE.md"
+  ],
+  "keywords": [
+    "ai",
+    "automation",
+    "workflow",
+    "claude",
+    "opencode",
+    "cli",
+    "autonomous",
+    "loop-mode",
+    "developer-tools"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sylphxltd/flow.git",
+    "directory": "packages/flow"
+  },
+  "bugs": {
+    "url": "https://github.com/sylphxltd/flow/issues"
+  },
+  "homepage": "https://github.com/sylphxltd/flow#readme",
+  "license": "MIT",
+  "author": "sylphxltd"
 }