nikcli 0.0.6

package/script/postinstall.mjs

@@ -0,0 +1,125 @@
+#!/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 = `nikcli-${platform}-${arch}`
+  const binaryName = platform === "windows" ? "nikcli.exe" : "nikcli"
+
+  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(`nikcli 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()
+    console.log(`Platform binary verified at: ${binaryPath}`)
+    console.log("Wrapper script will handle binary execution")
+  } catch (error) {
+    console.error("Failed to setup nikcli binary:", error.message)
+    process.exit(1)
+  }
+}
+
+try {
+  main()
+} catch (error) {
+  console.error("Postinstall script error:", error.message)
+  process.exit(0)
+}

package/script/publish-registries.ts

@@ -0,0 +1,187 @@
+#!/usr/bin/env bun
+import { $ } from "bun"
+import { Script } from "@nikcli-ai/script"
+
+if (!Script.preview) {
+  // Calculate SHA values
+  const arm64Sha = await $`sha256sum ./dist/nikcli-linux-arm64.tar.gz | cut -d' ' -f1`.text().then((x) => x.trim())
+  const x64Sha = await $`sha256sum ./dist/nikcli-linux-x64.tar.gz | cut -d' ' -f1`.text().then((x) => x.trim())
+  const macX64Sha = await $`sha256sum ./dist/nikcli-darwin-x64.zip | cut -d' ' -f1`.text().then((x) => x.trim())
+  const macArm64Sha = await $`sha256sum ./dist/nikcli-darwin-arm64.zip | cut -d' ' -f1`.text().then((x) => x.trim())
+
+  const [pkgver, _subver = ""] = Script.version.split(/(-.*)/, 2)
+
+  // arch
+  const binaryPkgbuild = [
+    "# Maintainer: dax",
+    "# Maintainer: adam",
+    "",
+    "pkgname='nikcli-bin'",
+    `pkgver=${pkgver}`,
+    `_subver=${_subver}`,
+    "options=('!debug' '!strip')",
+    "pkgrel=1",
+    "pkgdesc='The AI coding agent built for the terminal.'",
+    "url='https://github.com/nikomatt69/nikcli'",
+    "arch=('aarch64' 'x86_64')",
+    "license=('MIT')",
+    "provides=('nikcli')",
+    "conflicts=('nikcli')",
+    "depends=('ripgrep')",
+    "",
+    `source_aarch64=("\${pkgname}_\${pkgver}_aarch64.tar.gz::https://github.com/nikomatt69/nikcli/releases/download/v\${pkgver}\${_subver}/nikcli-linux-arm64.tar.gz")`,
+    `sha256sums_aarch64=('${arm64Sha}')`,
+
+    `source_x86_64=("\${pkgname}_\${pkgver}_x86_64.tar.gz::https://github.com/nikomatt69/nikcli/releases/download/v\${pkgver}\${_subver}/nikcli-linux-x64.tar.gz")`,
+    `sha256sums_x86_64=('${x64Sha}')`,
+    "",
+    "package() {",
+    '  install -Dm755 ./nikcli "${pkgdir}/usr/bin/nikcli"',
+    "}",
+    "",
+  ].join("\n")
+
+  // Source-based PKGBUILD for nikcli
+  const sourcePkgbuild = [
+    "# Maintainer: dax",
+    "# Maintainer: adam",
+    "",
+    "pkgname='nikcli'",
+    `pkgver=${pkgver}`,
+    `_subver=${_subver}`,
+    "options=('!debug' '!strip')",
+    "pkgrel=1",
+    "pkgdesc='The AI coding agent built for the terminal.'",
+    "url='https://github.com/nikomatt69/nikcli'",
+    "arch=('aarch64' 'x86_64')",
+    "license=('MIT')",
+    "provides=('nikcli')",
+    "conflicts=('nikcli-bin')",
+    "depends=('ripgrep')",
+    "makedepends=('git' 'bun' 'go')",
+    "",
+    `source=("nikcli-\${pkgver}.tar.gz::https://github.com/nikomatt69/nikcli/archive/v\${pkgver}\${_subver}.tar.gz")`,
+    `sha256sums=('SKIP')`,
+    "",
+    "build() {",
+    `  cd "nikcli-\${pkgver}"`,
+    `  bun install`,
+    "  cd ./packages/nikcli",
+    `  NIKCLI_CHANNEL=latest NIKCLI_VERSION=${pkgver} bun run ./script/build.ts --single`,
+    "}",
+    "",
+    "package() {",
+    `  cd "nikcli-\${pkgver}/packages/nikcli"`,
+    '  mkdir -p "${pkgdir}/usr/bin"',
+    '  target_arch="x64"',
+    '  case "$CARCH" in',
+    '    x86_64) target_arch="x64" ;;',
+    '    aarch64) target_arch="arm64" ;;',
+    '    *) printf "unsupported architecture: %s\\n" "$CARCH" >&2 ; return 1 ;;',
+    "  esac",
+    '  libc=""',
+    "  if command -v ldd >/dev/null 2>&1; then",
+    "    if ldd --version 2>&1 | grep -qi musl; then",
+    '      libc="-musl"',
+    "    fi",
+    "  fi",
+    '  if [ -z "$libc" ] && ls /lib/ld-musl-* >/dev/null 2>&1; then',
+    '    libc="-musl"',
+    "  fi",
+    '  base=""',
+    '  if [ "$target_arch" = "x64" ]; then',
+    "    if ! grep -qi avx2 /proc/cpuinfo 2>/dev/null; then",
+    '      base="-baseline"',
+    "    fi",
+    "  fi",
+    '  bin="dist/nikcli-linux-${target_arch}${base}${libc}/bin/nikcli"',
+    '  if [ ! -f "$bin" ]; then',
+    '    printf "unable to find binary for %s%s%s\\n" "$target_arch" "$base" "$libc" >&2',
+    "    return 1",
+    "  fi",
+    '  install -Dm755 "$bin" "${pkgdir}/usr/bin/nikcli"',
+    "}",
+    "",
+  ].join("\n")
+
+  for (const [pkg, pkgbuild] of [
+    ["nikcli-bin", binaryPkgbuild],
+    ["nikcli", sourcePkgbuild],
+  ]) {
+    for (let i = 0; i < 30; i++) {
+      try {
+        await $`rm -rf ./dist/aur-${pkg}`
+        await $`git clone ssh://aur@aur.archlinux.org/${pkg}.git ./dist/aur-${pkg}`
+        await $`cd ./dist/aur-${pkg} && git checkout master`
+        await Bun.file(`./dist/aur-${pkg}/PKGBUILD`).write(pkgbuild)
+        await $`cd ./dist/aur-${pkg} && makepkg --printsrcinfo > .SRCINFO`
+        await $`cd ./dist/aur-${pkg} && git add PKGBUILD .SRCINFO`
+        await $`cd ./dist/aur-${pkg} && git commit -m "Update to v${Script.version}"`
+        await $`cd ./dist/aur-${pkg} && git push`
+        break
+      } catch (e) {
+        continue
+      }
+    }
+  }
+
+  // Homebrew formula
+  const homebrewFormula = [
+    "# typed: false",
+    "# frozen_string_literal: true",
+    "",
+    "# This file was generated by GoReleaser. DO NOT EDIT.",
+    "class Nikcli < Formula",
+    `  desc "The AI coding agent built for the terminal."`,
+    `  homepage "https://github.com/nikomatt69/nikcli"`,
+    `  version "${Script.version.split("-")[0]}"`,
+    "",
+    `  depends_on "ripgrep"`,
+    "",
+    "  on_macos do",
+    "    if Hardware::CPU.intel?",
+    `      url "https://github.com/nikomatt69/nikcli/releases/download/v${Script.version}/nikcli-darwin-x64.zip"`,
+    `      sha256 "${macX64Sha}"`,
+    "",
+    "      def install",
+    '        bin.install "nikcli"',
+    "      end",
+    "    end",
+    "    if Hardware::CPU.arm?",
+    `      url "https://github.com/nikomatt69/nikcli/releases/download/v${Script.version}/nikcli-darwin-arm64.zip"`,
+    `      sha256 "${macArm64Sha}"`,
+    "",
+    "      def install",
+    '        bin.install "nikcli"',
+    "      end",
+    "    end",
+    "  end",
+    "",
+    "  on_linux do",
+    "    if Hardware::CPU.intel? and Hardware::CPU.is_64_bit?",
+    `      url "https://github.com/nikomatt69/nikcli/releases/download/v${Script.version}/nikcli-linux-x64.tar.gz"`,
+    `      sha256 "${x64Sha}"`,
+    "      def install",
+    '        bin.install "nikcli"',
+    "      end",
+    "    end",
+    "    if Hardware::CPU.arm? and Hardware::CPU.is_64_bit?",
+    `      url "https://github.com/nikomatt69/nikcli/releases/download/v${Script.version}/nikcli-linux-arm64.tar.gz"`,
+    `      sha256 "${arm64Sha}"`,
+    "      def install",
+    '        bin.install "nikcli"',
+    "      end",
+    "    end",
+    "  end",
+    "end",
+    "",
+    "",
+  ].join("\n")
+
+  await $`rm -rf ./dist/homebrew-tap`
+  await $`git clone https://${process.env["GITHUB_TOKEN"]}@github.com/sst/homebrew-tap.git ./dist/homebrew-tap`
+  await Bun.file("./dist/homebrew-tap/nikcli.rb").write(homebrewFormula)
+  await $`cd ./dist/homebrew-tap && git add nikcli.rb`
+  await $`cd ./dist/homebrew-tap && git commit -m "Update to v${Script.version}"`
+  await $`cd ./dist/homebrew-tap && git push`
+}

package/script/publish.ts

@@ -0,0 +1,100 @@
+#!/usr/bin/env bun
+import { $ } from "bun"
+import pkg from "../package.json"
+import { Script } from "@nikcli-ai/script"
+import { fileURLToPath } from "url"
+
+const dir = fileURLToPath(new URL("..", import.meta.url))
+process.chdir(dir)
+
+const { binaries } = await import("./build.ts")
+{
+  const name = `${pkg.name}-${process.platform}-${process.arch}`
+  console.log(`smoke test: running dist/${name}/bin/nikcli --version`)
+  await $`./dist/${name}/bin/nikcli --version`
+}
+
+await $`mkdir -p ./dist/${pkg.name}`
+await $`cp -r ./bin ./dist/${pkg.name}/bin`
+await $`cp ./script/postinstall.mjs ./dist/${pkg.name}/postinstall.mjs`
+
+await Bun.file(`./dist/${pkg.name}/package.json`).write(
+  JSON.stringify(
+    {
+      name: pkg.name + "-ai",
+      bin: {
+        [pkg.name]: `./bin/${pkg.name}`,
+      },
+      scripts: {
+        postinstall: "bun ./postinstall.mjs || node ./postinstall.mjs",
+      },
+      version: Script.version,
+      optionalDependencies: binaries,
+    },
+    null,
+    2,
+  ),
+)
+
+const tags = [Script.channel]
+
+function getStderr(err: any): string {
+  const s = err?.stderr
+  if (!s) return ""
+  if (s instanceof Uint8Array) return Buffer.from(s).toString()
+  return String(s)
+}
+
+async function npmPublish(cwd: string, tag: string) {
+  for (let attempt = 1; attempt <= 5; attempt++) {
+    try {
+      await $`npm publish *.tgz --access public --tag ${tag}`.cwd(cwd)
+      return
+    } catch (err: any) {
+      const stderr = getStderr(err)
+      const msg = String(err?.message ?? err) + stderr
+      if (stderr.includes("previously published versions") || msg.includes("previously published versions")) {
+        console.log(`[${cwd}] already published at this version, skipping`)
+        return
+      }
+      const isRateLimit = stderr.includes("E429") || msg.includes("E429")
+      if (!isRateLimit || attempt === 5) throw err
+      const delay = attempt * 60000
+      console.log(`[${cwd}] rate limited, retry ${attempt}/5 in ${delay / 1000}s...`)
+      await Bun.sleep(delay)
+    }
+  }
+}
+
+for (const [name] of Object.entries(binaries)) {
+  if (process.platform !== "win32") {
+    await $`chmod -R 755 .`.cwd(`./dist/${name}`)
+  }
+  await $`bun pm pack`.cwd(`./dist/${name}`)
+  for (const tag of tags) {
+    await npmPublish(`./dist/${name}`, tag)
+  }
+  await Bun.sleep(15000)
+}
+
+for (const tag of tags) {
+  await $`bun pm pack`.cwd(`./dist/${pkg.name}`)
+  await npmPublish(`./dist/${pkg.name}`, tag)
+}
+
+if (!Script.preview) {
+  // Create archives for GitHub release
+  for (const key of Object.keys(binaries)) {
+    if (key.includes("linux")) {
+      await $`tar -czf ../../${key}.tar.gz *`.cwd(`dist/${key}/bin`)
+    } else {
+      await $`zip -r ../../${key}.zip *`.cwd(`dist/${key}/bin`)
+    }
+  }
+
+  const image = "ghcr.io/nikomatt69/nikcli"
+  const platforms = "linux/amd64,linux/arm64"
+  const tags = [`${image}:${Script.version}`, `${image}:latest`]
+  const tagFlags = tags.flatMap((t) => ["-t", t])
+  await $`docker buildx build --platform ${platforms} ${tagFlags} --push .`
+}

package/script/schema.ts

@@ -0,0 +1,47 @@
+#!/usr/bin/env bun
+
+import { z } from "zod"
+import { Config } from "../src/config/config"
+
+const file = process.argv[2]
+console.log(file)
+
+const result = z.toJSONSchema(Config.Info, {
+  io: "input", // Generate input shape (treats optional().default() as not required)
+  /**
+   * We'll use the `default` values of the field as the only value in `examples`.
+   * This will ensure no docs are needed to be read, as the configuration is
+   * self-documenting.
+   *
+   * See https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-00#rfc.section.9.5
+   */
+  override(ctx) {
+    const schema = ctx.jsonSchema
+
+    // Preserve strictness: set additionalProperties: false for objects
+    if (schema && typeof schema === "object" && schema.type === "object" && schema.additionalProperties === undefined) {
+      schema.additionalProperties = false
+    }
+
+    // Add examples and default descriptions for string fields with defaults
+    if (schema && typeof schema === "object" && "type" in schema && schema.type === "string" && schema?.default) {
+      if (!schema.examples) {
+        schema.examples = [schema.default]
+      }
+
+      schema.description = [schema.description || "", `default: \`${schema.default}\``]
+        .filter(Boolean)
+        .join("\n\n")
+        .trim()
+    }
+  },
+}) as Record<string, unknown> & {
+  allowComments?: boolean
+  allowTrailingCommas?: boolean
+}
+
+// used for json lsps since config supports jsonc
+result.allowComments = true
+result.allowTrailingCommas = true
+
+await Bun.write(file, JSON.stringify(result, null, 2))

package/script/seed-e2e.ts

@@ -0,0 +1,50 @@
+const dir = process.env.NIKCLI_E2E_PROJECT_DIR ?? process.cwd()
+const title = process.env.NIKCLI_E2E_SESSION_TITLE ?? "E2E Session"
+const text = process.env.NIKCLI_E2E_MESSAGE ?? "Seeded for UI e2e"
+const model = process.env.NIKCLI_E2E_MODEL ?? "nikcli/gpt-5-nano"
+const parts = model.split("/")
+const providerID = parts[0] ?? "nikcli"
+const modelID = parts[1] ?? "gpt-5-nano"
+const now = Date.now()
+
+const seed = async () => {
+  const { Instance } = await import("../src/project/instance")
+  const { InstanceBootstrap } = await import("../src/project/bootstrap")
+  const { Session } = await import("../src/session")
+  const { Identifier } = await import("../src/id/id")
+  const { Project } = await import("../src/project/project")
+
+  await Instance.provide({
+    directory: dir,
+    init: InstanceBootstrap,
+    fn: async () => {
+      const session = await Session.create({ title })
+      const messageID = Identifier.descending("message")
+      const partID = Identifier.descending("part")
+      const message = {
+        id: messageID,
+        sessionID: session.id,
+        role: "user" as const,
+        time: { created: now },
+        agent: "build",
+        model: {
+          providerID,
+          modelID,
+        },
+      }
+      const part = {
+        id: partID,
+        sessionID: session.id,
+        messageID,
+        type: "text" as const,
+        text,
+        time: { start: now },
+      }
+      await Session.updateMessage(message)
+      await Session.updatePart(part)
+      await Project.update({ projectID: Instance.project.id, name: "E2E Project" })
+    },
+  })
+}
+
+await seed()