nikcli 0.0.6

package/src/flag/flag.ts

@@ -0,0 +1,128 @@
+function truthy(key: string) {
+  const value = process.env[key]?.toLowerCase()
+  return value === "true" || value === "1"
+}
+
+export namespace Flag {
+  export const NIKCLI_AUTO_SHARE = truthy("NIKCLI_AUTO_SHARE")
+  export const NIKCLI_GIT_BASH_PATH = process.env["NIKCLI_GIT_BASH_PATH"]
+  export const NIKCLI_CONFIG = process.env["NIKCLI_CONFIG"]
+  export declare const NIKCLI_CONFIG_DIR: string | undefined
+  export const NIKCLI_CONFIG_CONTENT = process.env["NIKCLI_CONFIG_CONTENT"]
+  export const NIKCLI_DISABLE_AUTOUPDATE = truthy("NIKCLI_DISABLE_AUTOUPDATE")
+  export const NIKCLI_DISABLE_PRUNE = truthy("NIKCLI_DISABLE_PRUNE")
+  export const NIKCLI_DISABLE_TERMINAL_TITLE = truthy("NIKCLI_DISABLE_TERMINAL_TITLE")
+  export const NIKCLI_PERMISSION = process.env["NIKCLI_PERMISSION"]
+  export const NIKCLI_DISABLE_DEFAULT_PLUGINS = truthy("NIKCLI_DISABLE_DEFAULT_PLUGINS")
+  export const NIKCLI_DISABLE_LSP_DOWNLOAD = truthy("NIKCLI_DISABLE_LSP_DOWNLOAD")
+  export const NIKCLI_ENABLE_EXPERIMENTAL_MODELS = truthy("NIKCLI_ENABLE_EXPERIMENTAL_MODELS")
+  export const NIKCLI_DISABLE_AUTOCOMPACT = truthy("NIKCLI_DISABLE_AUTOCOMPACT")
+  export const NIKCLI_DISABLE_MODELS_FETCH = truthy("NIKCLI_DISABLE_MODELS_FETCH")
+  export const NIKCLI_DISABLE_CLAUDE_CODE = truthy("NIKCLI_DISABLE_CLAUDE_CODE")
+  export const NIKCLI_DISABLE_CLAUDE_CODE_PROMPT =
+    NIKCLI_DISABLE_CLAUDE_CODE || truthy("NIKCLI_DISABLE_CLAUDE_CODE_PROMPT")
+  export const NIKCLI_DISABLE_CLAUDE_CODE_SKILLS =
+    NIKCLI_DISABLE_CLAUDE_CODE || truthy("NIKCLI_DISABLE_CLAUDE_CODE_SKILLS")
+  export const NIKCLI_DISABLE_EXTERNAL_SKILLS =
+    NIKCLI_DISABLE_CLAUDE_CODE_SKILLS || truthy("NIKCLI_DISABLE_EXTERNAL_SKILLS")
+  export declare const NIKCLI_DISABLE_PROJECT_CONFIG: boolean
+  export const NIKCLI_FAKE_VCS = process.env["NIKCLI_FAKE_VCS"]
+  export const NIKCLI_CLIENT = process.env["NIKCLI_CLIENT"] ?? "cli"
+  export const NIKCLI_SERVER_PASSWORD = process.env["NIKCLI_SERVER_PASSWORD"]
+  export const NIKCLI_SERVER_USERNAME = process.env["NIKCLI_SERVER_USERNAME"]
+  export const NIKCLI_SERVER_TAILSCALE_AUTH = truthy("NIKCLI_SERVER_TAILSCALE_AUTH")
+  export const NIKCLI_SERVER_TAILSCALE_USERS = process.env["NIKCLI_SERVER_TAILSCALE_USERS"]
+
+  // SSH Server
+  export const NIKCLI_SERVER_SSH_ENABLED = truthy("NIKCLI_SERVER_SSH_ENABLED")
+  export const NIKCLI_SERVER_SSH_PORT = parseInt(process.env["NIKCLI_SERVER_SSH_PORT"] ?? "2222")
+  export const NIKCLI_SERVER_SSH_HOST = process.env["NIKCLI_SERVER_SSH_HOST"] ?? "0.0.0.0"
+
+  // Connectors
+  export const NIKCLI_FIGMA_TOKEN = process.env["NIKCLI_FIGMA_TOKEN"]
+  export const NIKCLI_SLACK_BOT_TOKEN = process.env["NIKCLI_SLACK_BOT_TOKEN"]
+  export const NIKCLI_GITHUB_TOKEN = process.env["NIKCLI_GITHUB_TOKEN"]
+  export const NIKCLI_GITHUB_OAUTH_CLIENT_ID = process.env["NIKCLI_GITHUB_OAUTH_CLIENT_ID"] ?? process.env["GITHUB_CLIENT_ID_CONSOLE"] ?? process.env["GITHUB_CLIENT_ID"] ?? undefined
+  export const NIKCLI_LOVABLE_TOKEN = process.env["NIKCLI_LOVABLE_TOKEN"] ?? process.env["NIKCLI_LOVABLE_API_KEY"]
+  export const NIKCLI_LOVABLE_API_KEY = process.env["NIKCLI_LOVABLE_API_KEY"]
+
+  // Notifications
+  export const NIKCLI_SLACK_CHANNEL =
+    process.env["NIKCLI_SLACK_CHANNEL"] ?? process.env["SLACK_DEFAULT_CHANNEL"] ?? process.env["SLACK_CHANNEL"]
+  export const NIKCLI_DISCORD_WEBHOOK_URL =
+    process.env["NIKCLI_DISCORD_WEBHOOK_URL"] ?? process.env["DISCORD_WEBHOOK_URL"]
+  export const NIKCLI_TODO_NOTIFICATIONS = truthy("NIKCLI_TODO_NOTIFICATIONS")
+  export const NIKCLI_SLACK_TASK_NOTIFICATIONS =
+    truthy("NIKCLI_SLACK_TASK_NOTIFICATIONS") || truthy("SLACK_TASK_NOTIFICATIONS")
+  export const NIKCLI_DISCORD_TASK_NOTIFICATIONS =
+    truthy("NIKCLI_DISCORD_TASK_NOTIFICATIONS") || truthy("DISCORD_TASK_NOTIFICATIONS")
+
+  // TUI plugin system
+  export declare const NIKCLI_TUI_CONFIG: string | undefined
+  export const NIKCLI_PURE = truthy("NIKCLI_PURE")
+  export const NIKCLI_PLUGIN_META_FILE = process.env["NIKCLI_PLUGIN_META_FILE"]
+
+  // Experimental
+  export const NIKCLI_EXPERIMENTAL = truthy("NIKCLI_EXPERIMENTAL")
+  export const NIKCLI_EXPERIMENTAL_FILEWATCHER = truthy("NIKCLI_EXPERIMENTAL_FILEWATCHER")
+  export const NIKCLI_EXPERIMENTAL_DISABLE_FILEWATCHER = truthy("NIKCLI_EXPERIMENTAL_DISABLE_FILEWATCHER")
+  export const NIKCLI_EXPERIMENTAL_ICON_DISCOVERY = NIKCLI_EXPERIMENTAL || truthy("NIKCLI_EXPERIMENTAL_ICON_DISCOVERY")
+  export const NIKCLI_EXPERIMENTAL_DISABLE_COPY_ON_SELECT = truthy("NIKCLI_EXPERIMENTAL_DISABLE_COPY_ON_SELECT")
+  export const NIKCLI_ENABLE_EXA =
+    truthy("NIKCLI_ENABLE_EXA") || NIKCLI_EXPERIMENTAL || truthy("NIKCLI_EXPERIMENTAL_EXA")
+  export const NIKCLI_EXPERIMENTAL_BASH_MAX_OUTPUT_LENGTH = number("NIKCLI_EXPERIMENTAL_BASH_MAX_OUTPUT_LENGTH")
+  export const NIKCLI_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS = number("NIKCLI_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS")
+  export const NIKCLI_EXPERIMENTAL_OUTPUT_TOKEN_MAX = number("NIKCLI_EXPERIMENTAL_OUTPUT_TOKEN_MAX")
+  export const NIKCLI_EXPERIMENTAL_OXFMT = NIKCLI_EXPERIMENTAL || truthy("NIKCLI_EXPERIMENTAL_OXFMT")
+  export const NIKCLI_EXPERIMENTAL_LSP_TY = truthy("NIKCLI_EXPERIMENTAL_LSP_TY")
+  export const NIKCLI_EXPERIMENTAL_LSP_TOOL = NIKCLI_EXPERIMENTAL || truthy("NIKCLI_EXPERIMENTAL_LSP_TOOL")
+  export const NIKCLI_DISABLE_FILETIME_CHECK = truthy("NIKCLI_DISABLE_FILETIME_CHECK")
+  export const NIKCLI_EXPERIMENTAL_PLAN_MODE = NIKCLI_EXPERIMENTAL || truthy("NIKCLI_EXPERIMENTAL_PLAN_MODE")
+  export const NIKCLI_EXPERIMENTAL_WORKSPACES_TUI = NIKCLI_EXPERIMENTAL || truthy("NIKCLI_EXPERIMENTAL_WORKSPACES_TUI")
+  export const NIKCLI_EXPERIMENTAL_SECURITY_TOOL = NIKCLI_EXPERIMENTAL || truthy("NIKCLI_EXPERIMENTAL_SECURITY_TOOL")
+
+  function number(key: string) {
+    const value = process.env[key]
+    if (!value) return undefined
+    const parsed = Number(value)
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined
+  }
+}
+
+// Dynamic getter for NIKCLI_DISABLE_PROJECT_CONFIG
+Object.defineProperty(Flag, "NIKCLI_DISABLE_PROJECT_CONFIG", {
+  get() {
+    return truthy("NIKCLI_DISABLE_PROJECT_CONFIG")
+  },
+  enumerable: true,
+  configurable: false,
+})
+
+// Dynamic getter for NIKCLI_CONFIG_DIR
+Object.defineProperty(Flag, "NIKCLI_CONFIG_DIR", {
+  get() {
+    return process.env["NIKCLI_CONFIG_DIR"]
+  },
+  enumerable: true,
+  configurable: false,
+})
+
+Object.defineProperty(Flag, "NIKCLI_TUI_CONFIG", {
+  get() {
+    return process.env["NIKCLI_TUI_CONFIG"]
+  },
+  enumerable: true,
+  configurable: false,
+})
+
+Object.defineProperty(Flag, "NIKCLI_GITHUB_OAUTH_CLIENT_ID", {
+  get() {
+    return (
+      process.env["NIKCLI_GITHUB_OAUTH_CLIENT_ID"] ??
+      process.env["GITHUB_CLIENT_ID_CONSOLE"] ??
+      process.env["GITHUB_CLIENT_ID"]
+    )
+  },
+  enumerable: true,
+  configurable: false,
+})

package/src/format/formatter.ts

@@ -0,0 +1,356 @@
+import { readableStreamToText } from "bun"
+import { BunProc } from "../bun"
+import { Instance } from "../project/instance"
+import { Filesystem } from "../util/filesystem"
+import { Flag } from "@/flag/flag"
+
+export interface Info {
+  name: string
+  command: string[]
+  environment?: Record<string, string>
+  extensions: string[]
+  enabled(): Promise<boolean>
+}
+
+export const gofmt: Info = {
+  name: "gofmt",
+  command: ["gofmt", "-w", "$FILE"],
+  extensions: [".go"],
+  async enabled() {
+    return Bun.which("gofmt") !== null
+  },
+}
+
+export const mix: Info = {
+  name: "mix",
+  command: ["mix", "format", "$FILE"],
+  extensions: [".ex", ".exs", ".eex", ".heex", ".leex", ".neex", ".sface"],
+  async enabled() {
+    return Bun.which("mix") !== null
+  },
+}
+
+export const prettier: Info = {
+  name: "prettier",
+  command: [BunProc.which(), "x", "prettier", "--write", "$FILE"],
+  environment: {
+    BUN_BE_BUN: "1",
+  },
+  extensions: [
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts",
+    ".html",
+    ".htm",
+    ".css",
+    ".scss",
+    ".sass",
+    ".less",
+    ".vue",
+    ".svelte",
+    ".json",
+    ".jsonc",
+    ".yaml",
+    ".yml",
+    ".toml",
+    ".xml",
+    ".md",
+    ".mdx",
+    ".graphql",
+    ".gql",
+  ],
+  async enabled() {
+    const items = await Filesystem.findUp("package.json", Instance.directory, Instance.worktree)
+    for (const item of items) {
+      const json = await Bun.file(item).json()
+      if (json.dependencies?.prettier) return true
+      if (json.devDependencies?.prettier) return true
+    }
+    return false
+  },
+}
+
+export const oxfmt: Info = {
+  name: "oxfmt",
+  command: [BunProc.which(), "x", "oxfmt", "$FILE"],
+  environment: {
+    BUN_BE_BUN: "1",
+  },
+  extensions: [".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".mts", ".cts"],
+  async enabled() {
+    if (!Flag.NIKCLI_EXPERIMENTAL_OXFMT) return false
+    const items = await Filesystem.findUp("package.json", Instance.directory, Instance.worktree)
+    for (const item of items) {
+      const json = await Bun.file(item).json()
+      if (json.dependencies?.oxfmt) return true
+      if (json.devDependencies?.oxfmt) return true
+    }
+    return false
+  },
+}
+
+export const biome: Info = {
+  name: "biome",
+  command: [BunProc.which(), "x", "@biomejs/biome", "check", "--write", "$FILE"],
+  environment: {
+    BUN_BE_BUN: "1",
+  },
+  extensions: [
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts",
+    ".html",
+    ".htm",
+    ".css",
+    ".scss",
+    ".sass",
+    ".less",
+    ".vue",
+    ".svelte",
+    ".json",
+    ".jsonc",
+    ".yaml",
+    ".yml",
+    ".toml",
+    ".xml",
+    ".md",
+    ".mdx",
+    ".graphql",
+    ".gql",
+  ],
+  async enabled() {
+    const configs = ["biome.json", "biome.jsonc"]
+    for (const config of configs) {
+      const found = await Filesystem.findUp(config, Instance.directory, Instance.worktree)
+      if (found.length > 0) {
+        return true
+      }
+    }
+    return false
+  },
+}
+
+export const zig: Info = {
+  name: "zig",
+  command: ["zig", "fmt", "$FILE"],
+  extensions: [".zig", ".zon"],
+  async enabled() {
+    return Bun.which("zig") !== null
+  },
+}
+
+export const clang: Info = {
+  name: "clang-format",
+  command: ["clang-format", "-i", "$FILE"],
+  extensions: [".c", ".cc", ".cpp", ".cxx", ".c++", ".h", ".hh", ".hpp", ".hxx", ".h++", ".ino", ".C", ".H"],
+  async enabled() {
+    const items = await Filesystem.findUp(".clang-format", Instance.directory, Instance.worktree)
+    return items.length > 0
+  },
+}
+
+export const ktlint: Info = {
+  name: "ktlint",
+  command: ["ktlint", "-F", "$FILE"],
+  extensions: [".kt", ".kts"],
+  async enabled() {
+    return Bun.which("ktlint") !== null
+  },
+}
+
+export const ruff: Info = {
+  name: "ruff",
+  command: ["ruff", "format", "$FILE"],
+  extensions: [".py", ".pyi"],
+  async enabled() {
+    if (!Bun.which("ruff")) return false
+    const configs = ["pyproject.toml", "ruff.toml", ".ruff.toml"]
+    for (const config of configs) {
+      const found = await Filesystem.findUp(config, Instance.directory, Instance.worktree)
+      if (found.length > 0) {
+        if (config === "pyproject.toml") {
+          const content = await Bun.file(found[0]).text()
+          if (content.includes("[tool.ruff]")) return true
+        } else {
+          return true
+        }
+      }
+    }
+    const deps = ["requirements.txt", "pyproject.toml", "Pipfile"]
+    for (const dep of deps) {
+      const found = await Filesystem.findUp(dep, Instance.directory, Instance.worktree)
+      if (found.length > 0) {
+        const content = await Bun.file(found[0]).text()
+        if (content.includes("ruff")) return true
+      }
+    }
+    return false
+  },
+}
+
+export const rlang: Info = {
+  name: "air",
+  command: ["air", "format", "$FILE"],
+  extensions: [".R"],
+  async enabled() {
+    const airPath = Bun.which("air")
+    if (airPath == null) return false
+
+    try {
+      const proc = Bun.spawn(["air", "--help"], {
+        stdout: "pipe",
+        stderr: "pipe",
+      })
+      await proc.exited
+      const output = await readableStreamToText(proc.stdout)
+
+      const firstLine = output.split("\n")[0]
+      const hasR = firstLine.includes("R language")
+      const hasFormatter = firstLine.includes("formatter")
+      return hasR && hasFormatter
+    } catch (error) {
+      return false
+    }
+  },
+}
+
+export const uvformat: Info = {
+  name: "uv",
+  command: ["uv", "format", "--", "$FILE"],
+  extensions: [".py", ".pyi"],
+  async enabled() {
+    if (await ruff.enabled()) return false
+    if (Bun.which("uv") !== null) {
+      const proc = Bun.spawn(["uv", "format", "--help"], { stderr: "pipe", stdout: "pipe" })
+      const code = await proc.exited
+      return code === 0
+    }
+    return false
+  },
+}
+
+export const rubocop: Info = {
+  name: "rubocop",
+  command: ["rubocop", "--autocorrect", "$FILE"],
+  extensions: [".rb", ".rake", ".gemspec", ".ru"],
+  async enabled() {
+    return Bun.which("rubocop") !== null
+  },
+}
+
+export const standardrb: Info = {
+  name: "standardrb",
+  command: ["standardrb", "--fix", "$FILE"],
+  extensions: [".rb", ".rake", ".gemspec", ".ru"],
+  async enabled() {
+    return Bun.which("standardrb") !== null
+  },
+}
+
+export const htmlbeautifier: Info = {
+  name: "htmlbeautifier",
+  command: ["htmlbeautifier", "$FILE"],
+  extensions: [".erb", ".html.erb"],
+  async enabled() {
+    return Bun.which("htmlbeautifier") !== null
+  },
+}
+
+export const dart: Info = {
+  name: "dart",
+  command: ["dart", "format", "$FILE"],
+  extensions: [".dart"],
+  async enabled() {
+    return Bun.which("dart") !== null
+  },
+}
+
+export const ocamlformat: Info = {
+  name: "ocamlformat",
+  command: ["ocamlformat", "-i", "$FILE"],
+  extensions: [".ml", ".mli"],
+  async enabled() {
+    if (!Bun.which("ocamlformat")) return false
+    const items = await Filesystem.findUp(".ocamlformat", Instance.directory, Instance.worktree)
+    return items.length > 0
+  },
+}
+
+export const terraform: Info = {
+  name: "terraform",
+  command: ["terraform", "fmt", "$FILE"],
+  extensions: [".tf", ".tfvars"],
+  async enabled() {
+    return Bun.which("terraform") !== null
+  },
+}
+
+export const latexindent: Info = {
+  name: "latexindent",
+  command: ["latexindent", "-w", "-s", "$FILE"],
+  extensions: [".tex"],
+  async enabled() {
+    return Bun.which("latexindent") !== null
+  },
+}
+
+export const gleam: Info = {
+  name: "gleam",
+  command: ["gleam", "format", "$FILE"],
+  extensions: [".gleam"],
+  async enabled() {
+    return Bun.which("gleam") !== null
+  },
+}
+
+export const shfmt: Info = {
+  name: "shfmt",
+  command: ["shfmt", "-w", "$FILE"],
+  extensions: [".sh", ".bash"],
+  async enabled() {
+    return Bun.which("shfmt") !== null
+  },
+}
+
+export const nixfmt: Info = {
+  name: "nixfmt",
+  command: ["nixfmt", "$FILE"],
+  extensions: [".nix"],
+  async enabled() {
+    return Bun.which("nixfmt") !== null
+  },
+}
+
+export const rustfmt: Info = {
+  name: "rustfmt",
+  command: ["rustfmt", "$FILE"],
+  extensions: [".rs"],
+  async enabled() {
+    return Bun.which("rustfmt") !== null
+  },
+}
+
+export const pint: Info = {
+  name: "pint",
+  command: ["./vendor/bin/pint", "$FILE"],
+  extensions: [".php"],
+  async enabled() {
+    const items = await Filesystem.findUp("composer.json", Instance.directory, Instance.worktree)
+    for (const item of items) {
+      const json = await Bun.file(item).json()
+      if (json.require?.["laravel/pint"]) return true
+      if (json["require-dev"]?.["laravel/pint"]) return true
+    }
+    return false
+  },
+}

package/src/format/index.ts

@@ -0,0 +1,137 @@
+import { Bus } from "../bus"
+import { File } from "../file"
+import { Log } from "../util/log"
+import path from "path"
+import z from "zod"
+
+import * as Formatter from "./formatter"
+import { Config } from "../config/config"
+import { mergeDeep } from "remeda"
+import { Instance } from "../project/instance"
+
+export namespace Format {
+  const log = Log.create({ service: "format" })
+
+  export const Status = z
+    .object({
+      name: z.string(),
+      extensions: z.string().array(),
+      enabled: z.boolean(),
+    })
+    .meta({
+      ref: "FormatterStatus",
+    })
+  export type Status = z.infer<typeof Status>
+
+  const state = Instance.state(async () => {
+    const enabled: Record<string, boolean> = {}
+    const cfg = await Config.get()
+
+    const formatters: Record<string, Formatter.Info> = {}
+    if (cfg.formatter === false) {
+      log.info("all formatters are disabled")
+      return {
+        enabled,
+        formatters,
+      }
+    }
+
+    for (const item of Object.values(Formatter)) {
+      formatters[item.name] = item
+    }
+    for (const [name, item] of Object.entries(cfg.formatter ?? {})) {
+      if (item.disabled) {
+        delete formatters[name]
+        continue
+      }
+      const result: Formatter.Info = mergeDeep(formatters[name] ?? {}, {
+        command: [],
+        extensions: [],
+        ...item,
+      })
+
+      if (result.command.length === 0) continue
+
+      result.enabled = async () => true
+      result.name = name
+      formatters[name] = result
+    }
+
+    return {
+      enabled,
+      formatters,
+    }
+  })
+
+  async function isEnabled(item: Formatter.Info) {
+    const s = await state()
+    let status = s.enabled[item.name]
+    if (status === undefined) {
+      status = await item.enabled()
+      s.enabled[item.name] = status
+    }
+    return status
+  }
+
+  async function getFormatter(ext: string) {
+    const formatters = await state().then((x) => x.formatters)
+    const result = []
+    for (const item of Object.values(formatters)) {
+      log.info("checking", { name: item.name, ext })
+      if (!item.extensions.includes(ext)) continue
+      if (!(await isEnabled(item))) continue
+      log.info("enabled", { name: item.name, ext })
+      result.push(item)
+    }
+    return result
+  }
+
+  export async function status() {
+    const s = await state()
+    const result: Status[] = []
+    for (const formatter of Object.values(s.formatters)) {
+      const enabled = await isEnabled(formatter)
+      result.push({
+        name: formatter.name,
+        extensions: formatter.extensions,
+        enabled,
+      })
+    }
+    return result
+  }
+
+  export function init() {
+    log.info("init")
+    Bus.subscribe(File.Event.Edited, async (payload) => {
+      const file = payload.properties.file
+      log.info("formatting", { file })
+      const ext = path.extname(file)
+
+      for (const item of await getFormatter(ext)) {
+        log.info("running", { command: item.command })
+        try {
+          const proc = Bun.spawn({
+            cmd: item.command.map((x) => x.replace("$FILE", file)),
+            cwd: Instance.directory,
+            env: { ...process.env, ...item.environment },
+            stdout: "ignore",
+            stderr: "ignore",
+          })
+          const exit = await proc.exited
+          if (exit !== 0)
+            log.error("failed", {
+              command: item.command,
+              ...item.environment,
+            })
+        } catch (error) {
+          log.error("failed to format file", {
+            error,
+            command: item.command,
+            ...item.environment,
+            file,
+          })
+        }
+      }
+    })
+  }
+}

package/src/global/index.ts

@@ -0,0 +1,57 @@
+import fs from "fs/promises"
+import { xdgData, xdgCache, xdgConfig, xdgState } from "xdg-basedir"
+import path from "path"
+import os from "os"
+
+const app = "nikcli"
+
+const data = path.join(xdgData!, app)
+const cache = path.join(xdgCache!, app)
+const config = path.join(xdgConfig!, app)
+const state = path.join(xdgState!, app)
+
+export namespace Global {
+  export const Path = {
+    get home() {
+      return process.env.NIKCLI_TEST_HOME || os.homedir()
+    },
+    data,
+    bin: path.join(data, "bin"),
+    log: path.join(data, "log"),
+    cache,
+    config,
+    state,
+    get modelsDevUrl() {
+      return process.env.NIKCLI_MODELS_URL || "https://models.dev"
+    },
+  }
+}
+
+await Promise.all([
+  fs.mkdir(Global.Path.data, { recursive: true }),
+  fs.mkdir(Global.Path.config, { recursive: true }),
+  fs.mkdir(Global.Path.state, { recursive: true }),
+  fs.mkdir(Global.Path.log, { recursive: true }),
+  fs.mkdir(Global.Path.bin, { recursive: true }),
+])
+
+const CACHE_VERSION = "18"
+
+const version = await Bun.file(path.join(Global.Path.cache, "version"))
+  .text()
+  .catch(() => "0")
+
+if (version !== CACHE_VERSION) {
+  try {
+    const contents = await fs.readdir(Global.Path.cache)
+    await Promise.all(
+      contents.map((item) =>
+        fs.rm(path.join(Global.Path.cache, item), {
+          recursive: true,
+          force: true,
+        }),
+      ),
+    )
+  } catch (e) {}
+  await Bun.file(path.join(Global.Path.cache, "version")).write(CACHE_VERSION)
+}