@sylphx/flow 1.0.0 → 1.0.1

package/dist/shared/chunk-25dwp0dp.js

@@ -0,0 +1,89 @@
+import {
+  fileSystemError
+} from "./chunk-t4fbfa5v.js";
+import {
+  tryCatchAsync
+} from "./chunk-nd5fdvaq.js";
+import"./chunk-5j4w74t6.js";
+
+// src/composables/functional/useFileSystem.ts
+import fsPromises from "node:fs/promises";
+import path from "node:path";
+var joinPath = (...segments) => path.join(...segments);
+var resolvePath = (...segments) => path.resolve(...segments);
+var dirname = (filePath) => path.dirname(filePath);
+var basename = (filePath, ext) => path.basename(filePath, ext);
+var extname = (filePath) => path.extname(filePath);
+var readFile = async (filePath) => {
+  return tryCatchAsync(async () => {
+    return await fsPromises.readFile(filePath, "utf-8");
+  }, (error) => fileSystemError(`Failed to read file: ${filePath}`, filePath, "read", {
+    cause: error instanceof Error ? error : undefined
+  }));
+};
+var writeFile = async (filePath, content) => {
+  return tryCatchAsync(async () => {
+    await fsPromises.writeFile(filePath, content, "utf-8");
+  }, (error) => fileSystemError(`Failed to write file: ${filePath}`, filePath, "write", {
+    cause: error instanceof Error ? error : undefined
+  }));
+};
+var deleteFile = async (filePath) => {
+  return tryCatchAsync(async () => {
+    await fsPromises.unlink(filePath);
+  }, (error) => fileSystemError(`Failed to delete file: ${filePath}`, filePath, "delete", {
+    cause: error instanceof Error ? error : undefined
+  }));
+};
+var createDirectory = async (dirPath, options) => {
+  return tryCatchAsync(async () => {
+    await fsPromises.mkdir(dirPath, { recursive: options?.recursive ?? true });
+  }, (error) => fileSystemError(`Failed to create directory: ${dirPath}`, dirPath, "create", {
+    cause: error instanceof Error ? error : undefined
+  }));
+};
+var pathExists = async (filePath) => {
+  return tryCatchAsync(async () => {
+    try {
+      await fsPromises.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }, (error) => fileSystemError(`Failed to check if path exists: ${filePath}`, filePath, "stat", {
+    cause: error instanceof Error ? error : undefined
+  }));
+};
+var readDirectory = async (dirPath) => {
+  return tryCatchAsync(async () => {
+    return await fsPromises.readdir(dirPath);
+  }, (error) => fileSystemError(`Failed to read directory: ${dirPath}`, dirPath, "read", {
+    cause: error instanceof Error ? error : undefined
+  }));
+};
+var getStats = async (filePath) => {
+  return tryCatchAsync(async () => {
+    const stats = await fsPromises.stat(filePath);
+    return {
+      isFile: stats.isFile(),
+      isDirectory: stats.isDirectory(),
+      size: stats.size
+    };
+  }, (error) => fileSystemError(`Failed to get stats for: ${filePath}`, filePath, "stat", {
+    cause: error instanceof Error ? error : undefined
+  }));
+};
+export {
+  writeFile,
+  resolvePath,
+  readFile,
+  readDirectory,
+  pathExists,
+  joinPath,
+  getStats,
+  extname,
+  dirname,
+  deleteFile,
+  createDirectory,
+  basename
+};

package/dist/shared/chunk-3pjb6063.js

@@ -0,0 +1,208 @@
+import {
+  getProjectSettingsFile
+} from "./chunk-7eq34c42.js";
+import {
+  CLIError
+} from "./chunk-cjd3mk4c.js";
+
+// src/core/upgrade-manager.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import ora from "ora";
+var __dirname = "/home/runner/work/flow/flow/packages/flow/src/core";
+var execAsync = promisify(exec);
+
+class UpgradeManager {
+  projectPath;
+  options;
+  constructor(projectPath = process.cwd(), options = {}) {
+    this.projectPath = projectPath;
+    this.options = options;
+  }
+  async checkUpdates() {
+    if (this.options.verbose) {
+      console.log("检查更新...");
+    }
+    const [flowLatest, targetLatest] = await Promise.all([
+      this.getLatestFlowVersion(),
+      this.getLatestTargetVersion()
+    ]);
+    let flowVersion = null;
+    let targetVersion = null;
+    const flowCurrent = await this.getCurrentFlowVersion();
+    if (flowLatest && flowCurrent && flowLatest !== flowCurrent) {
+      flowVersion = { current: flowCurrent, latest: flowLatest };
+    }
+    const configPath = path.join(this.projectPath, getProjectSettingsFile());
+    try {
+      const config = JSON.parse(await fs.readFile(configPath, "utf-8"));
+      const target = config.target;
+      if (target) {
+        const targetCurrent = await this.getCurrentTargetVersion(target);
+        if (targetLatest && targetCurrent && targetLatest !== targetCurrent) {
+          targetVersion = { current: targetCurrent, latest: targetLatest };
+        }
+      }
+    } catch {}
+    return {
+      flowUpdate: !!flowVersion,
+      targetUpdate: !!targetVersion,
+      flowVersion,
+      targetVersion
+    };
+  }
+  async upgradeFlow(state) {
+    if (!state.outdated || !state.latestVersion) {
+      return false;
+    }
+    const spinner = ora("升级 Sylphx Flow...").start();
+    try {
+      if (!this.options.skipBackup) {
+        await this.backupConfig();
+      }
+      if (this.options.dryRun) {
+        spinner.succeed(`模拟升级: ${state.version} → ${state.latestVersion}`);
+        return true;
+      }
+      const configPath = path.join(this.projectPath, getProjectSettingsFile());
+      try {
+        const config = JSON.parse(await fs.readFile(configPath, "utf-8"));
+        config.version = state.latestVersion;
+        config.lastUpdated = new Date().toISOString();
+        await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+      } catch {}
+      spinner.succeed(`已升级到 ${state.latestVersion}`);
+      return true;
+    } catch (error) {
+      spinner.fail("升级失败");
+      throw new CLIError(`升级 Sylphx Flow 失败: ${error instanceof Error ? error.message : String(error)}`, "UPGRADE_FAILED");
+    }
+  }
+  async upgradeTarget(state) {
+    if (!state.target || !state.targetLatestVersion) {
+      return false;
+    }
+    const spinner = ora(`升级 ${state.target}...`).start();
+    try {
+      if (state.target === "claude-code") {
+        await this.upgradeClaudeCode();
+      } else if (state.target === "opencode") {
+        await this.upgradeOpenCode();
+      }
+      spinner.succeed(`${state.target} 已升级到最新版本`);
+      return true;
+    } catch (error) {
+      spinner.fail(`${state.target} 升级失败`);
+      throw new CLIError(`升级 ${state.target} 失败: ${error instanceof Error ? error.message : String(error)}`, "TARGET_UPGRADE_FAILED");
+    }
+  }
+  async upgradeClaudeCode() {
+    if (this.options.dryRun) {
+      console.log("模拟: claude update");
+      return;
+    }
+    const { stdout } = await execAsync("claude update");
+    if (this.options.verbose) {
+      console.log(stdout);
+    }
+  }
+  async upgradeOpenCode() {
+    if (this.options.dryRun) {
+      console.log("模拟: opencode upgrade");
+      return;
+    }
+    const { stdout } = await execAsync("opencode upgrade");
+    if (this.options.verbose) {
+      console.log(stdout);
+    }
+  }
+  async upgradeComponents(components) {
+    const upgraded = [];
+    for (const component of components) {
+      const spinner = ora(`升级 ${component}...`).start();
+      try {
+        await this.upgradeComponent(component);
+        spinner.succeed(`${component} 已升级`);
+        upgraded.push(component);
+      } catch (error) {
+        spinner.fail(`${component} 升级失败`);
+        if (this.options.verbose) {
+          console.error(error);
+        }
+      }
+    }
+    return upgraded;
+  }
+  async upgradeComponent(component) {
+    const componentPath = path.join(this.projectPath, ".claude", component);
+    await fs.rm(componentPath, { recursive: true, force: true });
+    if (this.options.dryRun) {
+      console.log(`模拟: 重新安装 ${component}`);
+    }
+  }
+  async backupConfig() {
+    const backupDir = this.options.backupPath || path.join(this.projectPath, ".claude-backup");
+    await fs.mkdir(backupDir, { recursive: true });
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const backupPath = path.join(backupDir, `backup-${timestamp}`);
+    const claudePath = path.join(this.projectPath, ".claude");
+    try {
+      await fs.cp(claudePath, path.join(backupPath, ".claude"), { recursive: true });
+    } catch {}
+    const configPath = path.join(this.projectPath, getProjectSettingsFile());
+    try {
+      await fs.cp(configPath, path.join(backupPath, getProjectSettingsFile()));
+    } catch {}
+    return backupPath;
+  }
+  async getCurrentFlowVersion() {
+    try {
+      const configPath = path.join(this.projectPath, getProjectSettingsFile());
+      const config = JSON.parse(await fs.readFile(configPath, "utf-8"));
+      return config.version || null;
+    } catch {
+      return null;
+    }
+  }
+  async getLatestFlowVersion() {
+    try {
+      const packagePath = path.join(__dirname, "..", "..", "package.json");
+      const packageJson = JSON.parse(await fs.readFile(packagePath, "utf-8"));
+      return packageJson.version || null;
+    } catch {
+      return null;
+    }
+  }
+  async getCurrentTargetVersion(target) {
+    if (target === "claude-code") {
+      try {
+        const { stdout } = await execAsync("claude --version");
+        const match = stdout.match(/v?(\d+\.\d+\.\d+)/);
+        return match ? match[1] : null;
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  async getLatestTargetVersion(target) {
+    if (target === "claude-code") {
+      try {
+        const { stdout } = await execAsync("npm view @anthropic-ai/claude-code version");
+        return stdout.trim();
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  static async isUpgradeAvailable() {
+    const manager = new UpgradeManager;
+    const updates = await manager.checkUpdates();
+    return updates.flowUpdate || updates.targetUpdate;
+  }
+}
+
+export { UpgradeManager };