@vikasitai/vikasit-code 2.0.6 → 2.0.8

package/script/fetch-models.ts

@@ -1,101 +0,0 @@
-#!/usr/bin/env bun
-// Preprocesses models.dev/api.json before it is embedded into the CLI binary.
-//
-// Two jobs:
-//   1. Strip OpenCode-branded providers ("opencode", "opencode-go") so their
-//      models don't leak into Vikasit Code's TUI / web / desktop pickers.
-//   2. Inject a first-class "vikasit-ai" provider built from
-//      config/zen-models.json so Vikasit AI appears as a native option for
-//      every user — including those without a custom ~/.config/vikasit
-//      provider block.
-//
-// The resulting JSON is written to a temp file. build.ts reads it via
-// MODELS_DEV_API_JSON (already-supported env var, see build.ts:24-25).
-//
-// Usage: bun run script/fetch-models.ts
-// Writes to: /tmp/vikasit-models-api.json
-// Prints: the absolute path of the written file (so callers can capture it).
-
-import fs from "fs"
-import path from "path"
-import { fileURLToPath } from "url"
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-const repoRoot = path.resolve(__dirname, "../../..")
-
-const MODELS_DEV_URL = process.env.VIKASIT_MODELS_URL || "https://models.dev"
-const OUTPUT = process.env.VIKASIT_MODELS_OUT || "/tmp/vikasit-models-api.json"
-
-type Provider = {
-  id?: string
-  env?: string[]
-  npm?: string
-  api?: string
-  name?: string
-  doc?: string
-  models?: Record<string, any>
-}
-
-async function main() {
-  console.log(`Fetching ${MODELS_DEV_URL}/api.json ...`)
-  const res = await fetch(`${MODELS_DEV_URL}/api.json`)
-  if (!res.ok) throw new Error(`models.dev fetch failed: ${res.status}`)
-  const api: Record<string, Provider> = await res.json()
-
-  // 1) strip OpenCode-branded providers
-  const stripped: string[] = []
-  for (const key of Object.keys(api)) {
-    if (key === "opencode" || key === "opencode-go") {
-      delete api[key]
-      stripped.push(key)
-    }
-  }
-  if (stripped.length) console.log(`Stripped providers: ${stripped.join(", ")}`)
-
-  // 2) inject vikasit-ai built from zen-models.json
-  const zenPath = path.join(repoRoot, "config", "zen-models.json")
-  if (fs.existsSync(zenPath)) {
-    const zen = JSON.parse(fs.readFileSync(zenPath, "utf-8"))
-    const today = new Date().toISOString().slice(0, 10)
-    const models: Record<string, any> = {}
-    for (const [id, raw] of Object.entries<any>(zen.models ?? {})) {
-      models[id] = {
-        id,
-        name: raw.name ?? id,
-        family: "vikasit-3",
-        attachment: true,
-        reasoning: false,
-        tool_call: true,
-        temperature: true,
-        release_date: today,
-        last_updated: today,
-        modalities: { input: ["text"], output: ["text"] },
-        open_weights: false,
-        cost: raw.cost ?? { input: 0, output: 0 },
-        limit: { context: 131072, output: 16384 },
-      }
-    }
-    api["vikasit-ai"] = {
-      id: "vikasit-ai",
-      env: ["VIKASIT_API_KEY"],
-      npm: "@ai-sdk/openai-compatible",
-      api: "https://vikasit.ai/zen/v1",
-      name: "Vikasit AI",
-      doc: "https://vikasit.ai/docs/models",
-      models,
-    }
-    console.log(`Injected vikasit-ai provider with ${Object.keys(models).length} models`)
-  } else {
-    console.warn(`config/zen-models.json not found at ${zenPath}; skipping vikasit-ai injection`)
-  }
-
-  fs.writeFileSync(OUTPUT, JSON.stringify(api))
-  console.log(`Wrote ${OUTPUT} (${Object.keys(api).length} providers)`)
-  // also print to stdout on the LAST line so callers can capture the path
-  process.stdout.write(`\n${OUTPUT}\n`)
-}
-
-main().catch((err) => {
-  console.error("fetch-models failed:", err)
-  process.exit(1)
-})

package/script/publish.ts

@@ -1,184 +0,0 @@
-#!/usr/bin/env bun
-import { $ } from "bun"
-import pkg from "../package.json"
-import { Script } from "@vikasit-code/script"
-import { fileURLToPath } from "url"
-
-const dir = fileURLToPath(new URL("..", import.meta.url))
-process.chdir(dir)
-
-const binaries: Record<string, string> = {}
-for (const filepath of new Bun.Glob("**/package.json").scanSync({ cwd: "./dist" })) {
-  const pkg = await Bun.file(`./dist/${filepath}`).json()
-  // Only include platform-specific binary packages, not the wrapper
-  if (pkg.name && pkg.version && pkg.os) {
-    binaries[pkg.name] = pkg.version
-  }
-}
-console.log("binaries", binaries)
-const version = Object.values(binaries)[0]
-
-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}/LICENSE`).write(await Bun.file("../../LICENSE").text())
-
-await Bun.file(`./dist/${pkg.name}/package.json`).write(
-  JSON.stringify(
-    {
-      name: "@vikasitai/" + pkg.name.replace("@vikasitai/", ""),
-      bin: {
-        vikasit: "./bin/vikasit",
-      },
-      scripts: {
-        postinstall: "bun ./postinstall.mjs || node ./postinstall.mjs",
-      },
-      version: version,
-      license: pkg.license,
-      optionalDependencies: binaries,
-    },
-    null,
-    2,
-  ),
-)
-
-const tasks = Object.entries(binaries).map(async ([name]) => {
-  if (process.platform !== "win32") {
-    await $`chmod -R 755 .`.cwd(`./dist/${name}`)
-  }
-  await $`bun pm pack`.cwd(`./dist/${name}`)
-  await $`npm publish *.tgz --access public --tag ${Script.channel}`.cwd(`./dist/${name}`)
-})
-await Promise.all(tasks)
-await $`cd ./dist/${pkg.name} && bun pm pack && npm publish *.tgz --access public --tag ${Script.channel}`
-
-const image = "ghcr.io/vikasit-ai/vikasit-code"
-const platforms = "linux/amd64,linux/arm64"
-const tags = [`${image}:${version}`, `${image}:${Script.channel}`]
-const tagFlags = tags.flatMap((t) => ["-t", t])
-await $`docker buildx build --platform ${platforms} ${tagFlags} --push .`
-
-// registries
-if (!Script.preview) {
-  // Calculate SHA values
-  const arm64Sha = await $`sha256sum ./dist/vikasit-linux-arm64.tar.gz | cut -d' ' -f1`.text().then((x) => x.trim())
-  const x64Sha = await $`sha256sum ./dist/vikasit-linux-x64.tar.gz | cut -d' ' -f1`.text().then((x) => x.trim())
-  const macX64Sha = await $`sha256sum ./dist/vikasit-darwin-x64.zip | cut -d' ' -f1`.text().then((x) => x.trim())
-  const macArm64Sha = await $`sha256sum ./dist/vikasit-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='vikasit-bin'",
-    `pkgver=${pkgver}`,
-    `_subver=${_subver}`,
-    "options=('!debug' '!strip')",
-    "pkgrel=1",
-    "pkgdesc='The AI coding agent built for the terminal.'",
-    "url='https://github.com/Vikasit-AI/vikasit-code'",
-    "arch=('aarch64' 'x86_64')",
-    "license=('MIT')",
-    "provides=('vikasit')",
-    "conflicts=('vikasit')",
-    "depends=('ripgrep')",
-    "",
-    `source_aarch64=("\${pkgname}_\${pkgver}_aarch64.tar.gz::https://github.com/Vikasit-AI/vikasit-code/releases/download/v\${pkgver}\${_subver}/vikasit-linux-arm64.tar.gz")`,
-    `sha256sums_aarch64=('${arm64Sha}')`,
-
-    `source_x86_64=("\${pkgname}_\${pkgver}_x86_64.tar.gz::https://github.com/Vikasit-AI/vikasit-code/releases/download/v\${pkgver}\${_subver}/vikasit-linux-x64.tar.gz")`,
-    `sha256sums_x86_64=('${x64Sha}')`,
-    "",
-    "package() {",
-    '  install -Dm755 ./vikasit "${pkgdir}/usr/bin/vikasit"',
-    "}",
-    "",
-  ].join("\n")
-
-  for (const [pkg, pkgbuild] of [["vikasit-bin", binaryPkgbuild]]) {
-    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 Vikasit < Formula",
-    `  desc "The AI coding agent built for the terminal."`,
-    `  homepage "https://github.com/Vikasit-AI/vikasit-code"`,
-    `  version "${Script.version.split("-")[0]}"`,
-    "",
-    `  depends_on "ripgrep"`,
-    "",
-    "  on_macos do",
-    "    if Hardware::CPU.intel?",
-    `      url "https://github.com/Vikasit-AI/vikasit-code/releases/download/v${Script.version}/vikasit-darwin-x64.zip"`,
-    `      sha256 "${macX64Sha}"`,
-    "",
-    "      def install",
-    '        bin.install "vikasit"',
-    "      end",
-    "    end",
-    "    if Hardware::CPU.arm?",
-    `      url "https://github.com/Vikasit-AI/vikasit-code/releases/download/v${Script.version}/vikasit-darwin-arm64.zip"`,
-    `      sha256 "${macArm64Sha}"`,
-    "",
-    "      def install",
-    '        bin.install "vikasit"',
-    "      end",
-    "    end",
-    "  end",
-    "",
-    "  on_linux do",
-    "    if Hardware::CPU.intel? and Hardware::CPU.is_64_bit?",
-    `      url "https://github.com/Vikasit-AI/vikasit-code/releases/download/v${Script.version}/vikasit-linux-x64.tar.gz"`,
-    `      sha256 "${x64Sha}"`,
-    "      def install",
-    '        bin.install "vikasit"',
-    "      end",
-    "    end",
-    "    if Hardware::CPU.arm? and Hardware::CPU.is_64_bit?",
-    `      url "https://github.com/Vikasit-AI/vikasit-code/releases/download/v${Script.version}/vikasit-linux-arm64.tar.gz"`,
-    `      sha256 "${arm64Sha}"`,
-    "      def install",
-    '        bin.install "vikasit"',
-    "      end",
-    "    end",
-    "  end",
-    "end",
-    "",
-    "",
-  ].join("\n")
-
-  const token = process.env.GITHUB_TOKEN
-  if (!token) {
-    console.error("GITHUB_TOKEN is required to update homebrew tap")
-    process.exit(1)
-  }
-  const tap = `https://x-access-token:${token}@github.com/Vikasit-AI/homebrew-tap.git`
-  await $`rm -rf ./dist/homebrew-tap`
-  await $`git clone ${tap} ./dist/homebrew-tap`
-  await Bun.file("./dist/homebrew-tap/vikasit.rb").write(homebrewFormula)
-  await $`cd ./dist/homebrew-tap && git add vikasit.rb`
-  await $`cd ./dist/homebrew-tap && git commit -m "Update to v${Script.version}"`
-  await $`cd ./dist/homebrew-tap && git push`
-}

package/script/schema.ts

@@ -1,63 +0,0 @@
-#!/usr/bin/env bun
-
-import { z } from "zod"
-import { Config } from "../src/config/config"
-import { TuiConfig } from "../src/config/tui"
-
-function generate(schema: z.ZodType) {
-  const result = z.toJSONSchema(schema, {
-    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
-
-  return result
-}
-
-const configFile = process.argv[2]
-const tuiFile = process.argv[3]
-
-console.log(configFile)
-await Bun.write(configFile, JSON.stringify(generate(Config.Info), null, 2))
-
-if (tuiFile) {
-  console.log(tuiFile)
-  await Bun.write(tuiFile, JSON.stringify(generate(TuiConfig.Info), null, 2))
-}

package/script/seed-e2e.ts

@@ -1,75 +0,0 @@
-const dir = process.env.VIKASIT_E2E_PROJECT_DIR ?? process.cwd()
-const title = process.env.VIKASIT_E2E_SESSION_TITLE ?? "E2E Session"
-const text = process.env.VIKASIT_E2E_MESSAGE ?? "Seeded for UI e2e"
-const model = process.env.VIKASIT_E2E_MODEL ?? "opencode/gpt-5-nano"
-const requirePaid = process.env.VIKASIT_E2E_REQUIRE_PAID === "true"
-const parts = model.split("/")
-const providerID = parts[0] ?? "vikasit"
-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 { Config } = await import("../src/config/config")
-  const { Provider } = await import("../src/provider/provider")
-  const { Session } = await import("../src/session")
-  const { MessageID, PartID } = await import("../src/session/schema")
-  const { Project } = await import("../src/project/project")
-  const { ModelID, ProviderID } = await import("../src/provider/schema")
-  const { ToolRegistry } = await import("../src/tool/registry")
-
-  try {
-    await Instance.provide({
-      directory: dir,
-      init: InstanceBootstrap,
-      fn: async () => {
-        await Config.waitForDependencies()
-        await ToolRegistry.ids()
-
-        if (requirePaid && providerID === "vikasit" && !process.env.VIKASIT_API_KEY) {
-          throw new Error("VIKASIT_API_KEY is required when VIKASIT_E2E_REQUIRE_PAID=true")
-        }
-
-        const info = await Provider.getModel(ProviderID.make(providerID), ModelID.make(modelID))
-        if (requirePaid) {
-          const paid =
-            info.cost.input > 0 || info.cost.output > 0 || info.cost.cache.read > 0 || info.cost.cache.write > 0
-          if (!paid) {
-            throw new Error(`VIKASIT_E2E_MODEL must resolve to a paid model: ${providerID}/${modelID}`)
-          }
-        }
-
-        const session = await Session.create({ title })
-        const messageID = MessageID.ascending()
-        const partID = PartID.ascending()
-        const message = {
-          id: messageID,
-          sessionID: session.id,
-          role: "user" as const,
-          time: { created: now },
-          agent: "build",
-          model: {
-            providerID: ProviderID.make(providerID),
-            modelID: ModelID.make(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" })
-      },
-    })
-  } finally {
-    await Instance.disposeAll().catch(() => {})
-  }
-}
-
-await seed()

package/script/upgrade-opentui.ts

@@ -1,64 +0,0 @@
-#!/usr/bin/env bun
-
-import path from "node:path"
-
-const raw = process.argv[2]
-if (!raw) {
-  console.error("Usage: bun run script/upgrade-opentui.ts <version>")
-  process.exit(1)
-}
-
-const ver = raw.replace(/^v/, "")
-const root = path.resolve(import.meta.dir, "../../..")
-const skip = new Set([".git", ".vikasit", ".turbo", "dist", "node_modules"])
-const keys = ["@opentui/core", "@opentui/solid"] as const
-
-const files = (await Array.fromAsync(new Bun.Glob("**/package.json").scan({ cwd: root }))).filter(
-  (file) => !file.split("/").some((part) => skip.has(part)),
-)
-
-const set = (cur: string) => {
-  if (cur.startsWith(">=")) return `>=${ver}`
-  if (cur.startsWith("^")) return `^${ver}`
-  if (cur.startsWith("~")) return `~${ver}`
-  return ver
-}
-
-const edit = (obj: unknown) => {
-  if (!obj || typeof obj !== "object") return false
-  const map = obj as Record<string, unknown>
-  return keys
-    .map((key) => {
-      const cur = map[key]
-      if (typeof cur !== "string") return false
-      const next = set(cur)
-      if (next === cur) return false
-      map[key] = next
-      return true
-    })
-    .some(Boolean)
-}
-
-const out = (
-  await Promise.all(
-    files.map(async (rel) => {
-      const file = path.join(root, rel)
-      const txt = await Bun.file(file).text()
-      const json = JSON.parse(txt)
-      const hit = [json.dependencies, json.devDependencies, json.peerDependencies].map(edit).some(Boolean)
-      if (!hit) return null
-      await Bun.write(file, `${JSON.stringify(json, null, 2)}\n`)
-      return rel
-    }),
-  )
-).filter((item): item is string => item !== null)
-
-if (out.length === 0) {
-  console.log("No opentui deps found")
-  process.exit(0)
-}
-
-console.log(`Updated opentui to ${ver} in:`)
-for (const file of out) {
-  console.log(`- ${file}`)
-}