@anieo/codegenie-cli 0.0.0-develop-202604071142 → 0.0.0-develop-202604072034

package/README.md

@@ -0,0 +1,57 @@
+# CodeGenie CLI
+
+`CodeGenie` 是面向 HarmonyOS 开发场景的 AI CLI。
+
+## 安装
+
+```bash
+npm install -g @anieo/codegenie-cli
+```
+
+预发布渠道：
+
+```bash
+npm install -g @anieo/codegenie-cli@beta
+npm install -g @anieo/codegenie-cli@alpha
+```
+
+安装完成后即可直接执行：
+
+```bash
+codegenie --version
+```
+
+说明：
+
+- npm 安装会直接创建全局 `codegenie` 命令
+- 如果 npm 因 optionalDependencies 配置跳过了平台包，安装脚本会自动补装当前平台包
+- npm 安装阶段会预热 runtime assets；Windows 还会额外隐藏预热一次默认启动路径，因此安装时间会略长，但首次可见启动会更快
+- 首次运行通常不再需要解包和安装依赖；首次进入某个工作区时，仍可能有少量项目级初始化
+- 首次运行不会再把二进制复制到 `~/.codegenie/bin`
+- npm 安装/升级会清理旧安装残留和临时更新残留
+- `upgrade` 在 npm 安装场景下会提示或委托执行 npm 升级命令，不直接覆写 npm 全局目录
+
+## 卸载
+
+推荐顺序：
+
+```bash
+codegenie uninstall --yes
+npm uninstall -g @anieo/codegenie-cli
+```
+
+说明：
+
+- `codegenie uninstall --yes` 删除 `~/.codegenie` 运行目录
+- `npm uninstall -g @anieo/codegenie-cli` 删除 npm 全局命令和包记录
+- npm 卸载生命周期脚本会做最佳努力清理，但不同 npm 版本行为不完全一致，不应只依赖 `npm uninstall -g`
+
+## 平台说明
+
+当前 staged 平台包：`@anieo/codegenie-cli-darwin-arm64`
+
+- `baseline` 兼容构建不进入 npm 正式发布范围
+
+## 发布说明
+
+仓库中的 `packages/npm/codegenie` 为元包模板。正式发布前请先运行仓库脚本生成 `dist/npm/` 下的 publishable 包，再按发布顺序上传各平台包和元包。

package/bin/codegenie.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+
+const { spawn } = require("child_process")
+const { buildLaunchEnv } = require("../lib/launch.js")
+const { resolveBinary } = require("../lib/resolve-binary.js")
+const { shouldPrintStartupHint, startupHintText } = require("../lib/startup-hint.js")
+
+const SPINNER = ["\u2807", "\u280B", "\u2819", "\u2838", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"]
+
+function main() {
+  const argv = process.argv.slice(2)
+  const showHint = shouldPrintStartupHint(argv)
+
+  let spinnerInterval = null
+  let spinnerIdx = 0
+  if (showHint && process.stderr.isTTY) {
+    process.stderr.write("\x1b[?25l")
+    const draw = () => {
+      process.stderr.write(`\r  \x1b[36m\x1b[1mCodeGenie\x1b[0m  \x1b[2m${SPINNER[spinnerIdx++ % SPINNER.length]} Loading...\x1b[0m`)
+    }
+    draw()
+    spinnerInterval = setInterval(draw, 100)
+  } else if (showHint) {
+    process.stderr.write(startupHintText() + "\n")
+  }
+
+  const resolved = resolveBinary()
+
+  const child = spawn(resolved.binaryPath, argv, {
+    stdio: "inherit",
+    env: buildLaunchEnv(resolved.packageName, resolved.platformDir, process.env),
+  })
+
+  child.on("spawn", () => {
+    if (spinnerInterval) {
+      clearInterval(spinnerInterval)
+      spinnerInterval = null
+    }
+  })
+
+  child.on("error", (err) => {
+    if (spinnerInterval) {
+      clearInterval(spinnerInterval)
+    }
+    process.stderr.write("\r\x1b[K\x1b[?25h")
+    console.error(`[codegenie] Failed to start ${resolved.packageName}: ${err.message}`)
+    process.exit(1)
+  })
+
+  child.on("exit", (code, signal) => {
+    if (spinnerInterval) {
+      clearInterval(spinnerInterval)
+    }
+    if (signal) {
+      process.kill(process.pid, signal)
+    } else {
+      process.exit(code ?? 1)
+    }
+  })
+
+  function forwardSignal(sig) {
+    if (child.pid) child.kill(sig)
+  }
+  process.on("SIGINT", forwardSignal)
+  process.on("SIGTERM", forwardSignal)
+}
+
+main()

package/bin/postinstall.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+
+const { execFileSync } = require("child_process")
+const { resolveBinary, resolvePackageName } = require("../lib/resolve-binary.js")
+const { prewarmBinary, warmStartupBinary } = require("../lib/prewarm.js")
+const packageJson = require("../package.json")
+
+function tryInstallPlatformPackage() {
+  let platformPackageName
+  try {
+    platformPackageName = resolvePackageName()
+  } catch {
+    return false
+  }
+
+  const platformVersion = packageJson.optionalDependencies && packageJson.optionalDependencies[platformPackageName]
+  const installSpec = platformVersion ? `${platformPackageName}@${platformVersion}` : platformPackageName
+  const npmExecutable = process.platform === "win32" ? "npm.cmd" : "npm"
+
+  console.log(`[codegenie] Platform package ${platformPackageName} not found, attempting to install...`)
+  try {
+    execFileSync(npmExecutable, ["install", "-g", installSpec], {
+      stdio: "inherit",
+      timeout: 120000,
+    })
+    return true
+  } catch (err) {
+    console.warn(`[codegenie] Failed to auto-install ${installSpec}: ${err && err.message ? err.message : String(err)}`)
+    return false
+  }
+}
+
+function runPostInstall() {
+  let resolved
+  try {
+    resolved = resolveBinary()
+  } catch (firstError) {
+    const attempted = tryInstallPlatformPackage()
+    if (!attempted) {
+      const message = firstError && firstError.message ? firstError.message : String(firstError)
+      console.warn("[codegenie] npm install completed, but platform binary verification will be deferred to first launch.")
+      console.warn(message)
+      return
+    }
+    try {
+      resolved = resolveBinary()
+    } catch (retryError) {
+      const message = retryError && retryError.message ? retryError.message : String(retryError)
+      console.warn("[codegenie] npm install completed, but platform binary verification will be deferred to first launch.")
+      console.warn(message)
+      return
+    }
+  }
+
+  console.log("[codegenie] npm install complete. Global command \"codegenie\" is ready.")
+  console.log(`[codegenie] Using platform package ${resolved.packageName}.`)
+  console.log("[codegenie] Prewarming runtime assets during npm install...")
+  let result = prewarmBinary(resolved.binaryPath, resolved.platformDir)
+  if (result.error || (typeof result.status === "number" && result.status !== 0)) {
+    const reason = result.error ? result.error.message : `exit code ${result.status}`
+    console.warn(`[codegenie] Runtime prewarm attempt 1 failed (${reason}), retrying...`)
+    result = prewarmBinary(resolved.binaryPath, resolved.platformDir)
+  }
+  if (result.error) {
+    console.warn(`[codegenie] Runtime prewarm failed: ${result.error.message}`)
+  } else if (typeof result.status === "number" && result.status !== 0) {
+    console.warn(`[codegenie] Runtime prewarm exited with code ${result.status}. First launch will finish initialization.`)
+  } else {
+    console.log("[codegenie] Runtime assets are ready. First launch should be faster.")
+  }
+
+  if (process.platform === "win32" && process.env.CODEGENIE_SKIP_WARM_STARTUP !== "true") {
+    console.log("[codegenie] Finalizing hidden first-launch warmup...")
+    const startupWarm = warmStartupBinary(resolved.binaryPath, resolved.platformDir)
+    if (startupWarm.error) {
+      console.warn(`[codegenie] Hidden startup warmup failed: ${startupWarm.error.message}`)
+    } else if (typeof startupWarm.status === "number" && startupWarm.status !== 0) {
+      console.warn(`[codegenie] Hidden startup warmup exited with code ${startupWarm.status}. First visible launch may still be slower.`)
+    }
+  }
+}
+
+runPostInstall()

package/bin/uninstall.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+const { cleanupAfterNpmUninstall, cleanupLegacyLoginState } = require("../lib/cleanup.js")
+
+try {
+  const result = cleanupAfterNpmUninstall()
+  if (result.removed) {
+    console.log(`[codegenie] Removed runtime directory: ${result.rootDir}`)
+  } else if (result.reason === "package-mismatch") {
+    console.log(`[codegenie] Skip runtime cleanup because install context belongs to another npm package.`)
+  } else if (result.reason === "missing") {
+    console.log("[codegenie] Runtime directory already removed.")
+  } else if (result.reason === "remove-failed") {
+    const hint = result.error && result.error.message ? ` (${result.error.message})` : ""
+    console.warn(`[codegenie] Failed to remove runtime directory${hint}. Remove manually: ${result.rootDir}`)
+  }
+
+  if (result.removed || result.reason === "missing") {
+    const legacyState = cleanupLegacyLoginState()
+    if (legacyState.removed) {
+      console.log(`[codegenie] Removed legacy login state: ${legacyState.path}`)
+    } else if (legacyState.reason === "remove-failed") {
+      const hint = legacyState.error && legacyState.error.message ? ` (${legacyState.error.message})` : ""
+      console.warn(`[codegenie] Failed to remove legacy login state${hint}. Remove manually: ${legacyState.path}`)
+    }
+  }
+} catch (error) {
+  const message = error && error.message ? error.message : String(error)
+  console.warn(`[codegenie] Runtime cleanup during npm uninstall failed: ${message}`)
+}

package/lib/cleanup.js

@@ -0,0 +1,121 @@
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+
+function runtimePaths(homeDir = os.homedir()) {
+  const rootDir = path.join(homeDir, ".codegenie")
+  const binDir = path.join(rootDir, "bin")
+  return {
+    rootDir,
+    binDir,
+    binaryPath: path.join(binDir, process.platform === "win32" ? "codegenie.exe" : "codegenie"),
+    installContextPath: path.join(rootDir, "install-context.json"),
+  }
+}
+
+function legacyLoginStatePath(homeDir = os.homedir()) {
+  return path.join(homeDir, ".config", "ts-login")
+}
+
+function isRecord(value) {
+  return typeof value === "object" && value !== null
+}
+
+function belongsToExpectedPackageFamily(actualPackageName, expectedPackageName) {
+  return actualPackageName === expectedPackageName || actualPackageName.startsWith(`${expectedPackageName}-`)
+}
+
+function readInstallContext(homeDir = os.homedir()) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(runtimePaths(homeDir).installContextPath, "utf-8"))
+    if (!isRecord(raw)) return null
+    if (raw.installSource !== "npm" && raw.installSource !== "standalone") return null
+    return {
+      installSource: raw.installSource,
+      npmPackageName:
+        typeof raw.npmPackageName === "string" && raw.npmPackageName.trim() ? raw.npmPackageName.trim() : null,
+    }
+  } catch {
+    return null
+  }
+}
+
+function removeWithRetry(targetPath, maxRetries = 2) {
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      fs.rmSync(targetPath, { recursive: true, force: true })
+      return { success: true, error: null }
+    } catch (err) {
+      const code = err && err.code
+      if ((code === "EBUSY" || code === "EPERM") && attempt < maxRetries) {
+        const delay = (attempt + 1) * 500
+        const end = Date.now() + delay
+        while (Date.now() < end) { /* busy wait */ }
+        continue
+      }
+      return { success: false, error: err }
+    }
+  }
+  return { success: false, error: null }
+}
+
+function cleanupAfterNpmUninstall(options = {}) {
+  const homeDir = options.homeDir || os.homedir()
+  const expectedPackageName =
+    options.expectedPackageName || process.env.CODEGENIE_NPM_PACKAGE || process.env.npm_package_name || null
+  const paths = runtimePaths(homeDir)
+  const context = readInstallContext(homeDir)
+
+  if (
+    context &&
+    expectedPackageName &&
+    context.npmPackageName &&
+    context.installSource === "npm" &&
+    !belongsToExpectedPackageFamily(context.npmPackageName, expectedPackageName)
+  ) {
+    return { removed: false, reason: "package-mismatch", rootDir: paths.rootDir }
+  }
+
+  if (!fs.existsSync(paths.rootDir)) {
+    return { removed: false, reason: "missing", rootDir: paths.rootDir }
+  }
+
+  const result = removeWithRetry(paths.rootDir)
+  if (!result.success) {
+    return {
+      removed: false,
+      reason: "remove-failed",
+      rootDir: paths.rootDir,
+      error: result.error,
+    }
+  }
+  return { removed: true, reason: "removed", rootDir: paths.rootDir }
+}
+
+function cleanupLegacyLoginState(options = {}) {
+  const homeDir = options.homeDir || os.homedir()
+  const targetPath = legacyLoginStatePath(homeDir)
+  if (!fs.existsSync(targetPath)) {
+    return { removed: false, reason: "missing", path: targetPath }
+  }
+  const result = removeWithRetry(targetPath)
+  if (!result.success) {
+    return {
+      removed: false,
+      reason: "remove-failed",
+      path: targetPath,
+      error: result.error,
+    }
+  }
+  return { removed: true, reason: "removed", path: targetPath }
+}
+
+module.exports = {
+  belongsToExpectedPackageFamily,
+  cleanupAfterNpmUninstall,
+  cleanupLegacyLoginState,
+  legacyLoginStatePath,
+  readInstallContext,
+  removeWithRetry,
+  runtimePaths,
+}

package/lib/launch.js

@@ -0,0 +1,18 @@
+const packageJson = require("../package.json")
+
+function buildLaunchEnv(resolvedPackageName, platformDir, baseEnv = process.env) {
+  const env = {
+    ...baseEnv,
+    CODEGENIE_INSTALL_SOURCE: "npm",
+    CODEGENIE_NPM_PACKAGE: packageJson.name,
+    CODEGENIE_NPM_PLATFORM_PACKAGE: resolvedPackageName,
+  }
+  if (platformDir) {
+    env.CODEGENIE_NPM_PLATFORM_DIR = platformDir
+  }
+  return env
+}
+
+module.exports = {
+  buildLaunchEnv,
+}

package/lib/prewarm.js

@@ -0,0 +1,78 @@
+const fs = require("fs")
+const os = require("os")
+const { spawnSync } = require("child_process")
+
+function buildPrewarmEnv(platformDir, baseEnv = process.env) {
+  const env = {
+    ...baseEnv,
+    CODEGENIE_PREPARE_ONLY: "true",
+    CODEGENIE_INSTALL_SOURCE: "npm",
+    CODEGENIE_NPM_PACKAGE:
+      baseEnv.CODEGENIE_NPM_PACKAGE || baseEnv.npm_package_name || "codegenie",
+  }
+  if (platformDir) {
+    env.CODEGENIE_NPM_PLATFORM_DIR = platformDir
+  }
+  return env
+}
+
+function prewarmBinary(binaryPath, platformDir, spawnImpl = spawnSync, baseEnv = process.env) {
+  return spawnImpl(binaryPath, [], {
+    stdio: "ignore",
+    timeout: 120000,
+    env: buildPrewarmEnv(platformDir, baseEnv),
+  })
+}
+
+function buildStartupWarmEnv(platformDir, baseEnv = process.env) {
+  const env = {
+    ...baseEnv,
+    CODEGENIE_WARM_STARTUP: "true",
+    CODEGENIE_WARM_STARTUP_TIMEOUT_MS: baseEnv.CODEGENIE_WARM_STARTUP_TIMEOUT_MS || "10000",
+    CODEGENIE_INSTALL_SOURCE: "npm",
+    CODEGENIE_NPM_PACKAGE:
+      baseEnv.CODEGENIE_NPM_PACKAGE || baseEnv.npm_package_name || "codegenie",
+    OPENCODE_DISABLE_AUTOUPDATE: "true",
+  }
+  if (platformDir) {
+    env.CODEGENIE_NPM_PLATFORM_DIR = platformDir
+  }
+  return env
+}
+
+function resolveWarmupCwd(baseEnv = process.env, existsImpl = fs.existsSync) {
+  const initCwd = typeof baseEnv.INIT_CWD === "string" ? baseEnv.INIT_CWD.trim() : ""
+  if (initCwd && existsImpl(initCwd)) {
+    return initCwd
+  }
+
+  const userProfile = typeof baseEnv.USERPROFILE === "string" ? baseEnv.USERPROFILE.trim() : ""
+  if (userProfile) {
+    return userProfile
+  }
+
+  const home = typeof baseEnv.HOME === "string" ? baseEnv.HOME.trim() : ""
+  if (home) {
+    return home
+  }
+
+  return os.homedir()
+}
+
+function warmStartupBinary(binaryPath, platformDir, spawnImpl = spawnSync, baseEnv = process.env, existsImpl = fs.existsSync) {
+  return spawnImpl(binaryPath, [], {
+    stdio: "ignore",
+    timeout: 20000,
+    windowsHide: true,
+    cwd: resolveWarmupCwd(baseEnv, existsImpl),
+    env: buildStartupWarmEnv(platformDir, baseEnv),
+  })
+}
+
+module.exports = {
+  buildPrewarmEnv,
+  buildStartupWarmEnv,
+  prewarmBinary,
+  resolveWarmupCwd,
+  warmStartupBinary,
+}

package/lib/resolve-binary.js

@@ -0,0 +1,107 @@
+      
+const fs = require("fs")
+const path = require("path")
+
+function loadPlatformMap() {
+  const platformMapPath = path.join(__dirname, "..", "platform-map.json")
+  return JSON.parse(fs.readFileSync(platformMapPath, "utf8"))
+}
+
+function detectLibc() {
+  if (process.platform !== "linux") return null
+  if (process.report && typeof process.report.getReport === "function") {
+    const report = process.report.getReport()
+    if (report && report.header && report.header.glibcVersionRuntime) {
+      return "glibc"
+    }
+  }
+  return "musl"
+}
+
+function resolvePackageName() {
+  const platformMap = loadPlatformMap()
+  const libc = detectLibc()
+
+  let platformKey = null
+  if (process.platform === "darwin" && process.arch === "arm64") platformKey = "darwin-arm64"
+  else if (process.platform === "darwin" && process.arch === "x64") platformKey = "darwin-x64"
+  else if (process.platform === "linux" && process.arch === "arm64" && libc === "musl") platformKey = "linux-arm64-musl"
+  else if (process.platform === "linux" && process.arch === "arm64") platformKey = "linux-arm64"
+  else if (process.platform === "linux" && process.arch === "x64" && libc === "musl") platformKey = "linux-x64-musl"
+  else if (process.platform === "linux" && process.arch === "x64") platformKey = "linux-x64"
+  else if (process.platform === "win32" && process.arch === "x64") platformKey = "win32-x64"
+
+  if (platformKey && platformMap[platformKey]) {
+    return platformMap[platformKey]
+  }
+
+  const libcSuffix = libc ? `/${libc}` : ""
+  throw new Error(`Unsupported npm platform: ${process.platform}/${process.arch}${libcSuffix}`)
+}
+
+function resolvePlatformPackageDir(packageName) {
+  const packageJsonPath = require.resolve(`${packageName}/package.json`)
+  return path.dirname(packageJsonPath)
+}
+
+function ensureExecutable(binaryPath) {
+  if (process.platform === "win32") {
+    return
+  }
+  try {
+    const stats = fs.statSync(binaryPath)
+    const mode = stats.mode & 0o777
+    if (mode !== 0o755 && mode !== 0o775 && mode !== 0o777) {
+      fs.chmodSync(binaryPath, 0o755)
+    }
+  } catch {
+    // ignore permission check failure
+  }
+}
+
+function resolveBinary() {
+  const packageName = resolvePackageName()
+  let platformDir = ""
+  try {
+    platformDir = resolvePlatformPackageDir(packageName)
+  } catch (error) {
+    const metaPackageName = (() => {
+      try { return require("../package.json").name } catch { return null }
+    })() || process.env.npm_package_name || "@hippox/codegenie"
+    const hint = [
+      `[codegenie] Failed to locate installed binary package for ${process.platform}/${process.arch}.`,
+      `[codegenie] Expected package: ${packageName}`,
+      `[codegenie] Reinstall with \`npm install -g ${metaPackageName}\`.`,
+      `[codegenie] If your npm disables optionalDependencies, install \`${packageName}\` manually and retry.`,
+    ].join("\n")
+    const wrapped = new Error(hint)
+    wrapped.cause = error
+    throw wrapped
+  }
+
+  const binaryPath = path.join(
+    platformDir,
+    "bin",
+    process.platform === "win32" ? "codegenie.exe" : "codegenie",
+  )
+  if (!fs.existsSync(binaryPath)) {
+    throw new Error(`[codegenie] Binary file missing from ${packageName}: ${binaryPath}`)
+  }
+
+  ensureExecutable(binaryPath)
+
+  return {
+    packageName,
+    binaryPath,
+    platformDir,
+  }
+}
+
+module.exports = {
+  detectLibc,
+  resolveBinary,
+  resolvePlatformPackageDir,
+  resolvePackageName,
+}
+
+    

package/lib/startup-hint.js

@@ -0,0 +1,31 @@
+const NON_INTERACTIVE_ARGS = new Set([
+  "--version", "-v", "--help", "-h",
+  "check-update", "upgrade", "rollback", "uninstall",
+  "login", "logout",
+])
+
+function isInteractiveLaunch(argv = []) {
+  if (argv.length === 0) return true
+  if (argv[0] === "run" || argv[0] === "--") return true
+  return false
+}
+
+function shouldPrintStartupHint(argv = [], options = {}) {
+  const env = options.env || process.env
+  const isTTY = options.isTTY ?? process.stderr.isTTY
+
+  if (!isTTY) return false
+  if (env.CODEGENIE_PREPARE_ONLY === "true" || env.CODEGENIE_WARM_STARTUP === "true") return false
+  if (argv.length > 0 && NON_INTERACTIVE_ARGS.has(argv[0])) return false
+  return isInteractiveLaunch(argv)
+}
+
+function startupHintText() {
+  return "\x1b[36m\x1b[1m  CodeGenie\x1b[0m\x1b[2m  Loading...\x1b[0m"
+}
+
+module.exports = {
+  isInteractiveLaunch,
+  shouldPrintStartupHint,
+  startupHintText,
+}

package/package.json

@@ -1,14 +1,38 @@
 {
   "name": "@anieo/codegenie-cli",
-  "bin": {
-    "codegenie": "./bin/codegenie"
-  },
+  "version": "0.0.0-develop-202604072034",
+  "private": false,
+  "description": "HarmonyOS AI 开发 CLI，通过 npm 分发平台二进制",
+  "license": "MIT",
   "scripts": {
-    "postinstall": "bun ./postinstall.mjs || node ./postinstall.mjs"
+    "postinstall": "node ./bin/postinstall.js",
+    "preuninstall": "node ./bin/uninstall.js",
+    "uninstall": "node ./bin/uninstall.js",
+    "postuninstall": "node ./bin/uninstall.js"
   },
-  "version": "0.0.0-develop-202604071142",
-  "license": "MIT",
+  "bin": {
+    "codegenie": "bin/codegenie.js"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "README.md",
+    "platform-map.json"
+  ],
+  "keywords": [
+    "cli",
+    "harmonyos",
+    "codegenie",
+    "ai"
+  ],
   "optionalDependencies": {
-    "codegenie-darwin-arm64": "0.0.0-develop-202604071142"
+    "@anieo/codegenie-cli-darwin-arm64": "0.0.0-develop-202604072034"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://gitcode.com/codegenie/codegenie.git"
   }
 }

package/platform-map.json

@@ -0,0 +1,3 @@
+{
+  "darwin-arm64": "@anieo/codegenie-cli-darwin-arm64"
+}

package/bin/codegenie

@@ -1,179 +0,0 @@
-#!/usr/bin/env node
-
-const childProcess = require("child_process")
-const fs = require("fs")
-const path = require("path")
-const os = require("os")
-
-function run(target) {
-  const result = childProcess.spawnSync(target, process.argv.slice(2), {
-    stdio: "inherit",
-  })
-  if (result.error) {
-    console.error(result.error.message)
-    process.exit(1)
-  }
-  const code = typeof result.status === "number" ? result.status : 0
-  process.exit(code)
-}
-
-const envPath = process.env.CODEGENIE_BIN_PATH
-if (envPath) {
-  run(envPath)
-}
-
-const scriptPath = fs.realpathSync(__filename)
-const scriptDir = path.dirname(scriptPath)
-
-//
-const cached = path.join(scriptDir, ".codegenie")
-if (fs.existsSync(cached)) {
-  run(cached)
-}
-
-const platformMap = {
-  darwin: "darwin",
-  linux: "linux",
-  win32: "windows",
-}
-const archMap = {
-  x64: "x64",
-  arm64: "arm64",
-  arm: "arm",
-}
-
-let platform = platformMap[os.platform()]
-if (!platform) {
-  platform = os.platform()
-}
-let arch = archMap[os.arch()]
-if (!arch) {
-  arch = os.arch()
-}
-const base = "codegenie-" + platform + "-" + arch
-const binary = platform === "windows" ? "codegenie.exe" : "codegenie"
-
-function supportsAvx2() {
-  if (arch !== "x64") return false
-
-  if (platform === "linux") {
-    try {
-      return /(^|\s)avx2(\s|$)/i.test(fs.readFileSync("/proc/cpuinfo", "utf8"))
-    } catch {
-      return false
-    }
-  }
-
-  if (platform === "darwin") {
-    try {
-      const result = childProcess.spawnSync("sysctl", ["-n", "hw.optional.avx2_0"], {
-        encoding: "utf8",
-        timeout: 1500,
-      })
-      if (result.status !== 0) return false
-      return (result.stdout || "").trim() === "1"
-    } catch {
-      return false
-    }
-  }
-
-  if (platform === "windows") {
-    const cmd =
-      '(Add-Type -MemberDefinition "[DllImport(""kernel32.dll"")] public static extern bool IsProcessorFeaturePresent(int ProcessorFeature);" -Name Kernel32 -Namespace Win32 -PassThru)::IsProcessorFeaturePresent(40)'
-
-    for (const exe of ["powershell.exe", "pwsh.exe", "pwsh", "powershell"]) {
-      try {
-        const result = childProcess.spawnSync(exe, ["-NoProfile", "-NonInteractive", "-Command", cmd], {
-          encoding: "utf8",
-          timeout: 3000,
-          windowsHide: true,
-        })
-        if (result.status !== 0) continue
-        const out = (result.stdout || "").trim().toLowerCase()
-        if (out === "true" || out === "1") return true
-        if (out === "false" || out === "0") return false
-      } catch {
-        continue
-      }
-    }
-
-    return false
-  }
-
-  return false
-}
-
-const names = (() => {
-  const avx2 = supportsAvx2()
-  const baseline = arch === "x64" && !avx2
-
-  if (platform === "linux") {
-    const musl = (() => {
-      try {
-        if (fs.existsSync("/etc/alpine-release")) return true
-      } catch {
-        // ignore
-      }
-
-      try {
-        const result = childProcess.spawnSync("ldd", ["--version"], { encoding: "utf8" })
-        const text = ((result.stdout || "") + (result.stderr || "")).toLowerCase()
-        if (text.includes("musl")) return true
-      } catch {
-        // ignore
-      }
-
-      return false
-    })()
-
-    if (musl) {
-      if (arch === "x64") {
-        if (baseline) return [`${base}-baseline-musl`, `${base}-musl`, `${base}-baseline`, base]
-        return [`${base}-musl`, `${base}-baseline-musl`, base, `${base}-baseline`]
-      }
-      return [`${base}-musl`, base]
-    }
-
-    if (arch === "x64") {
-      if (baseline) return [`${base}-baseline`, base, `${base}-baseline-musl`, `${base}-musl`]
-      return [base, `${base}-baseline`, `${base}-musl`, `${base}-baseline-musl`]
-    }
-    return [base, `${base}-musl`]
-  }
-
-  if (arch === "x64") {
-    if (baseline) return [`${base}-baseline`, base]
-    return [base, `${base}-baseline`]
-  }
-  return [base]
-})()
-
-function findBinary(startDir) {
-  let current = startDir
-  for (;;) {
-    const modules = path.join(current, "node_modules")
-    if (fs.existsSync(modules)) {
-      for (const name of names) {
-        const candidate = path.join(modules, name, "bin", binary)
-        if (fs.existsSync(candidate)) return candidate
-      }
-    }
-    const parent = path.dirname(current)
-    if (parent === current) {
-      return
-    }
-    current = parent
-  }
-}
-
-const resolved = findBinary(scriptDir)
-if (!resolved) {
-  console.error(
-    "It seems that your package manager failed to install the right version of the codegenie CLI for your platform. You can try manually installing " +
-      names.map((n) => `\"${n}\"`).join(" or ") +
-      " package",
-  )
-  process.exit(1)
-}
-
-run(resolved)

package/postinstall.mjs

@@ -1,131 +0,0 @@
-#!/usr/bin/env node
-
-import fs from "fs"
-import path from "path"
-import os from "os"
-import { fileURLToPath } from "url"
-import { createRequire } from "module"
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-const require = createRequire(import.meta.url)
-
-function detectPlatformAndArch() {
-  // Map platform names
-  let platform
-  switch (os.platform()) {
-    case "darwin":
-      platform = "darwin"
-      break
-    case "linux":
-      platform = "linux"
-      break
-    case "win32":
-      platform = "windows"
-      break
-    default:
-      platform = os.platform()
-      break
-  }
-
-  // Map architecture names
-  let arch
-  switch (os.arch()) {
-    case "x64":
-      arch = "x64"
-      break
-    case "arm64":
-      arch = "arm64"
-      break
-    case "arm":
-      arch = "arm"
-      break
-    default:
-      arch = os.arch()
-      break
-  }
-
-  return { platform, arch }
-}
-
-function findBinary() {
-  const { platform, arch } = detectPlatformAndArch()
-  const packageName = `codegenie-${platform}-${arch}`
-  const binaryName = platform === "windows" ? "codegenie.exe" : "codegenie"
-
-  try {
-    // Use require.resolve to find the package
-    const packageJsonPath = require.resolve(`${packageName}/package.json`)
-    const packageDir = path.dirname(packageJsonPath)
-    const binaryPath = path.join(packageDir, "bin", binaryName)
-
-    if (!fs.existsSync(binaryPath)) {
-      throw new Error(`Binary not found at ${binaryPath}`)
-    }
-
-    return { binaryPath, binaryName }
-  } catch (error) {
-    throw new Error(`Could not find package ${packageName}: ${error.message}`)
-  }
-}
-
-function prepareBinDirectory(binaryName) {
-  const binDir = path.join(__dirname, "bin")
-  const targetPath = path.join(binDir, binaryName)
-
-  // Ensure bin directory exists
-  if (!fs.existsSync(binDir)) {
-    fs.mkdirSync(binDir, { recursive: true })
-  }
-
-  // Remove existing binary/symlink if it exists
-  if (fs.existsSync(targetPath)) {
-    fs.unlinkSync(targetPath)
-  }
-
-  return { binDir, targetPath }
-}
-
-function symlinkBinary(sourcePath, binaryName) {
-  const { targetPath } = prepareBinDirectory(binaryName)
-
-  fs.symlinkSync(sourcePath, targetPath)
-  console.log(`codegenie binary symlinked: ${targetPath} -> ${sourcePath}`)
-
-  // Verify the file exists after operation
-  if (!fs.existsSync(targetPath)) {
-    throw new Error(`Failed to symlink binary to ${targetPath}`)
-  }
-}
-
-async function main() {
-  try {
-    if (os.platform() === "win32") {
-      // On Windows, the .exe is already included in the package and bin field points to it
-      // No postinstall setup needed
-      console.log("Windows detected: binary setup not needed (using packaged .exe)")
-      return
-    }
-
-    // On non-Windows platforms, just verify the binary package exists
-    // Don't replace the wrapper script - it handles binary execution
-    const { binaryPath } = findBinary()
-    const target = path.join(__dirname, "bin", ".codegenie")
-    if (fs.existsSync(target)) fs.unlinkSync(target)
-    try {
-      fs.linkSync(binaryPath, target)
-    } catch {
-      fs.copyFileSync(binaryPath, target)
-    }
-    fs.chmodSync(target, 0o755)
-  } catch (error) {
-    console.error("Failed to setup codegenie binary:", error.message)
-    process.exit(1)
-  }
-}
-
-try {
-  main()
-} catch (error) {
-  console.error("Postinstall script error:", error.message)
-  process.exit(0)
-}