@vikasitai/vikasit-code 2.0.6 → 2.0.8

package/src/cli/cmd/tui/attach.ts

@@ -1,88 +0,0 @@
-import { cmd } from "../cmd"
-import { UI } from "@/cli/ui"
-import { tui } from "./app"
-import { win32DisableProcessedInput, win32InstallCtrlCGuard } from "./win32"
-import { TuiConfig } from "@/config/tui"
-import { Instance } from "@/project/instance"
-import { existsSync } from "fs"
-
-export const AttachCommand = cmd({
-  command: "attach <url>",
-  describe: "attach to a running vikasit server",
-  builder: (yargs) =>
-    yargs
-      .positional("url", {
-        type: "string",
-        describe: "http://localhost:4096",
-        demandOption: true,
-      })
-      .option("dir", {
-        type: "string",
-        description: "directory to run in",
-      })
-      .option("continue", {
-        alias: ["c"],
-        describe: "continue the last session",
-        type: "boolean",
-      })
-      .option("session", {
-        alias: ["s"],
-        type: "string",
-        describe: "session id to continue",
-      })
-      .option("fork", {
-        type: "boolean",
-        describe: "fork the session when continuing (use with --continue or --session)",
-      })
-      .option("password", {
-        alias: ["p"],
-        type: "string",
-        describe: "basic auth password (defaults to VIKASIT_SERVER_PASSWORD)",
-      }),
-  handler: async (args) => {
-    const unguard = win32InstallCtrlCGuard()
-    try {
-      win32DisableProcessedInput()
-
-      if (args.fork && !args.continue && !args.session) {
-        UI.error("--fork requires --continue or --session")
-        process.exitCode = 1
-        return
-      }
-
-      const directory = (() => {
-        if (!args.dir) return undefined
-        try {
-          process.chdir(args.dir)
-          return process.cwd()
-        } catch {
-          // If the directory doesn't exist locally (remote attach), pass it through.
-          return args.dir
-        }
-      })()
-      const headers = (() => {
-        const password = args.password ?? process.env.VIKASIT_SERVER_PASSWORD
-        if (!password) return undefined
-        const auth = `Basic ${Buffer.from(`vikasit:${password}`).toString("base64")}`
-        return { Authorization: auth }
-      })()
-      const config = await Instance.provide({
-        directory: directory && existsSync(directory) ? directory : process.cwd(),
-        fn: () => TuiConfig.get(),
-      })
-      await tui({
-        url: args.url,
-        config,
-        args: {
-          continue: args.continue,
-          sessionID: args.session,
-          fork: args.fork,
-        },
-        directory,
-        headers,
-      })
-    } finally {
-      unguard?.()
-    }
-  },
-})

package/src/cli/cmd/tui/component/border.tsx

@@ -1,21 +0,0 @@
-export const EmptyBorder = {
-  topLeft: "",
-  bottomLeft: "",
-  vertical: "",
-  topRight: "",
-  bottomRight: "",
-  horizontal: " ",
-  bottomT: "",
-  topT: "",
-  cross: "",
-  leftT: "",
-  rightT: "",
-}
-
-export const SplitBorder = {
-  border: ["left" as const, "right" as const],
-  customBorderChars: {
-    ...EmptyBorder,
-    vertical: "┃",
-  },
-}

package/src/cli/cmd/tui/component/dialog-agent.tsx

@@ -1,31 +0,0 @@
-import { createMemo } from "solid-js"
-import { useLocal } from "@tui/context/local"
-import { DialogSelect } from "@tui/ui/dialog-select"
-import { useDialog } from "@tui/ui/dialog"
-
-export function DialogAgent() {
-  const local = useLocal()
-  const dialog = useDialog()
-
-  const options = createMemo(() =>
-    local.agent.list().map((item) => {
-      return {
-        value: item.name,
-        title: item.name,
-        description: item.native ? "native" : item.description,
-      }
-    }),
-  )
-
-  return (
-    <DialogSelect
-      title="Select agent"
-      current={local.agent.current().name}
-      options={options()}
-      onSelect={(option) => {
-        local.agent.set(option.value)
-        dialog.clear()
-      }}
-    />
-  )
-}

package/src/cli/cmd/tui/component/dialog-command.tsx

@@ -1,171 +0,0 @@
-import { useDialog } from "@tui/ui/dialog"
-import { DialogSelect, type DialogSelectOption, type DialogSelectRef } from "@tui/ui/dialog-select"
-import {
-  createContext,
-  createMemo,
-  createSignal,
-  getOwner,
-  onCleanup,
-  runWithOwner,
-  useContext,
-  type Accessor,
-  type ParentProps,
-} from "solid-js"
-import { useKeyboard } from "@opentui/solid"
-import { useKeybind } from "@tui/context/keybind"
-
-type Context = ReturnType<typeof init>
-const ctx = createContext<Context>()
-
-export type Slash = {
-  name: string
-  aliases?: string[]
-}
-
-export type CommandOption = DialogSelectOption<string> & {
-  keybind?: string
-  suggested?: boolean
-  slash?: Slash
-  hidden?: boolean
-  enabled?: boolean
-}
-
-function init() {
-  const root = getOwner()
-  const [registrations, setRegistrations] = createSignal<Accessor<CommandOption[]>[]>([])
-  const [suspendCount, setSuspendCount] = createSignal(0)
-  const dialog = useDialog()
-  const keybind = useKeybind()
-
-  const entries = createMemo(() => {
-    const all = registrations().flatMap((x) => x())
-    return all.map((x) => ({
-      ...x,
-      footer: x.keybind ? keybind.print(x.keybind) : undefined,
-    }))
-  })
-
-  const isEnabled = (option: CommandOption) => option.enabled !== false
-  const isVisible = (option: CommandOption) => isEnabled(option) && !option.hidden
-
-  const visibleOptions = createMemo(() => entries().filter((option) => isVisible(option)))
-  const suggestedOptions = createMemo(() =>
-    visibleOptions()
-      .filter((option) => option.suggested)
-      .map((option) => ({
-        ...option,
-        value: `suggested:${option.value}`,
-        category: "Suggested",
-      })),
-  )
-  const suspended = () => suspendCount() > 0
-
-  useKeyboard((evt) => {
-    if (suspended()) return
-    if (dialog.stack.length > 0) return
-    for (const option of entries()) {
-      if (!isEnabled(option)) continue
-      if (option.keybind && keybind.match(option.keybind, evt)) {
-        evt.preventDefault()
-        option.onSelect?.(dialog)
-        return
-      }
-    }
-  })
-
-  const result = {
-    trigger(name: string) {
-      for (const option of entries()) {
-        if (option.value === name) {
-          if (!isEnabled(option)) return
-          option.onSelect?.(dialog)
-          return
-        }
-      }
-    },
-    slashes() {
-      return visibleOptions().flatMap((option) => {
-        const slash = option.slash
-        if (!slash) return []
-        return {
-          display: "/" + slash.name,
-          description: option.description ?? option.title,
-          aliases: slash.aliases?.map((alias) => "/" + alias),
-          onSelect: () => result.trigger(option.value),
-        }
-      })
-    },
-    keybinds(enabled: boolean) {
-      setSuspendCount((count) => count + (enabled ? -1 : 1))
-    },
-    suspended,
-    show() {
-      dialog.replace(() => <DialogCommand options={visibleOptions()} suggestedOptions={suggestedOptions()} />)
-    },
-    register(cb: () => CommandOption[]) {
-      const owner = getOwner() ?? root
-      if (!owner) return () => {}
-
-      let list: Accessor<CommandOption[]> | undefined
-
-      // TUI plugins now register commands via an async store that runs outside an active reactive scope.
-      // runWithOwner attaches createMemo/onCleanup to this owner so plugin registrations stay reactive and dispose correctly.
-      runWithOwner(owner, () => {
-        list = createMemo(cb)
-        const ref = list
-        if (!ref) return
-        setRegistrations((arr) => [ref, ...arr])
-        onCleanup(() => {
-          setRegistrations((arr) => arr.filter((x) => x !== ref))
-        })
-      })
-
-      if (!list) return () => {}
-      let done = false
-      return () => {
-        if (done) return
-        done = true
-        const ref = list
-        if (!ref) return
-        setRegistrations((arr) => arr.filter((x) => x !== ref))
-      }
-    },
-  }
-  return result
-}
-
-export function useCommandDialog() {
-  const value = useContext(ctx)
-  if (!value) {
-    throw new Error("useCommandDialog must be used within a CommandProvider")
-  }
-  return value
-}
-
-export function CommandProvider(props: ParentProps) {
-  const value = init()
-  const dialog = useDialog()
-  const keybind = useKeybind()
-
-  useKeyboard((evt) => {
-    if (value.suspended()) return
-    if (dialog.stack.length > 0) return
-    if (evt.defaultPrevented) return
-    if (keybind.match("command_list", evt)) {
-      evt.preventDefault()
-      value.show()
-      return
-    }
-  })
-
-  return <ctx.Provider value={value}>{props.children}</ctx.Provider>
-}
-
-function DialogCommand(props: { options: CommandOption[]; suggestedOptions: CommandOption[] }) {
-  let ref: DialogSelectRef<string>
-  const list = () => {
-    if (ref?.filter) return props.options
-    return [...props.suggestedOptions, ...props.options]
-  }
-  return <DialogSelect ref={(r) => (ref = r)} title="Commands" options={list()} />
-}

package/src/cli/cmd/tui/component/dialog-login.tsx

@@ -1,156 +0,0 @@
-import { useTheme } from "@tui/context/theme"
-import { useDialog } from "@tui/ui/dialog"
-import { useToast } from "@tui/ui/toast"
-import { DialogPrompt } from "@tui/ui/dialog-prompt"
-import { useSDK } from "@tui/context/sdk"
-import { useSync } from "@tui/context/sync"
-import { unlockLoginGate } from "./login-gate"
-import open from "open"
-import { createSignal, onMount } from "solid-js"
-import fs from "fs"
-import path from "path"
-import os from "os"
-
-declare const VIKASIT_CONSOLE_URL_DEFAULT: string | undefined
-const CONSOLE_URL =
-  process.env["VIKASIT_CONSOLE_URL"] ||
-  (typeof VIKASIT_CONSOLE_URL_DEFAULT !== "undefined" ? VIKASIT_CONSOLE_URL_DEFAULT : "https://vikasit.ai")
-
-/**
- * Validate the API key by making a real chat completion request.
- * Set vikasit-3 as default model.
- */
-async function validateKeyAndSetModel(apiKey: string): Promise<boolean> {
-  try {
-    // Validate key by checking if it's a valid key format and exists
-    // The key starts with "sk-" and is 67 chars long
-    if (!apiKey.startsWith("sk-") || apiKey.length < 20) return false
-
-    // Quick validation: hit models endpoint with the key
-    // The server validates the key and returns models
-    const res = await fetch(`${CONSOLE_URL}/zen/v1/models`, {
-      headers: { Authorization: `Bearer ${apiKey}` },
-    })
-
-    if (!res.ok) {
-      await res.text()
-      return false
-    }
-
-    await res.json()
-
-    // Set default model
-    try {
-      const configDir = path.join(os.homedir(), ".config", "vikasit")
-      fs.mkdirSync(configDir, { recursive: true })
-      const configPath = path.join(configDir, "vikasit.json")
-      let config: Record<string, unknown> = {}
-      try {
-        config = JSON.parse(fs.readFileSync(configPath, "utf-8"))
-      } catch {}
-      config.model = "vikasit-ai/vikasit-3"
-      // Ensure Vikasit provider is configured with all models
-      if (!config.provider || !(config.provider as any)["vikasit-ai"]) {
-        config.provider = {
-          ...((config.provider as Record<string, unknown>) || {}),
-          "vikasit-ai": {
-            npm: "@ai-sdk/openai-compatible",
-            name: "Vikasit AI",
-            api: CONSOLE_URL + "/zen/v1",
-            env: ["VIKASIT_API_KEY"],
-            models: {
-              "vikasit-3-flash": { name: "Vikasit 3 Flash", attachment: true, maxTokens: 8192, context: 32768, cost: { input: 0, output: 0 } },
-              "vikasit-3-coder": { name: "Vikasit 3 Coder", attachment: true, reasoning: true, maxTokens: 16384, context: 131072, cost: { input: 0, output: 0 } },
-              "vikasit-3": { name: "Vikasit 3 235B", attachment: true, reasoning: true, maxTokens: 16384, context: 131072, cost: { input: 0, output: 0 } },
-              "vikasit-3-fast": { name: "Vikasit 3 Fast 397B", attachment: true, reasoning: true, maxTokens: 16384, context: 131072, cost: { input: 0, output: 0 } },
-              "vikasit-3-max": { name: "Vikasit 3 Max 480B", attachment: true, reasoning: true, maxTokens: 16384, context: 131072, cost: { input: 0, output: 0 } },
-            },
-          },
-        }
-      }
-      fs.writeFileSync(configPath, JSON.stringify(config, null, 2))
-    } catch {}
-
-    return true
-  } catch {
-    return false
-  }
-}
-
-async function storeKeyAndUnlock(
-  key: string,
-  sdk: ReturnType<typeof useSDK>,
-  sync: ReturnType<typeof useSync>,
-  dialog: ReturnType<typeof useDialog>,
-  toast: ReturnType<typeof useToast>,
-) {
-  const valid = await validateKeyAndSetModel(key)
-
-  if (!valid) {
-    toast.show({ variant: "error", message: "Invalid API key. Check and try again." })
-    return
-  }
-
-  await sdk.client.auth.set({
-    providerID: "vikasit-ai",
-    auth: { type: "api", key },
-  })
-
-  unlockLoginGate(true)
-  dialog.clear()
-
-  toast.show({
-    variant: "success",
-    message: "Signed in successfully · Default model: vikasit-3",
-  })
-
-  // Refresh providers in background (non-blocking)
-  sdk.client.instance.dispose().then(() => sync.bootstrap()).catch(() => {})
-}
-
-export function DialogLogin() {
-  const dialog = useDialog()
-  const sdk = useSDK()
-  const sync = useSync()
-  const toast = useToast()
-  const { theme } = useTheme()
-  const [busy, setBusy] = createSignal(false)
-
-  onMount(() => {
-    // Open the web auth page in the browser
-    try {
-      open(`${CONSOLE_URL}/auth/authorize`)
-    } catch {}
-  })
-
-  return (
-    <DialogPrompt
-      title="Sign in to Vikasit AI"
-      placeholder="Paste your API key here (sk-...)"
-      busy={busy()}
-      busyText="Validating key..."
-      description={() => (
-        <box gap={1}>
-          <text fg={theme.text}>
-            <b>Browser opened to sign in with GitHub</b>
-          </text>
-          <text fg={theme.textMuted}>1. Sign in with GitHub in your browser</text>
-          <text fg={theme.textMuted}>2. Go to API Keys in your workspace</text>
-          <text fg={theme.textMuted}>3. Copy your API key and paste it above</text>
-        </box>
-      )}
-      onConfirm={async (value) => {
-        if (!value || !value.trim()) return
-        const key = value.trim()
-        setBusy(true)
-        try {
-          await storeKeyAndUnlock(key, sdk, sync, dialog, toast)
-        } catch {
-          toast.show({ variant: "error", message: "Failed to sign in. Try again." })
-        } finally {
-          setBusy(false)
-        }
-      }}
-    />
-  )
-}

package/src/cli/cmd/tui/component/dialog-mcp.tsx

@@ -1,86 +0,0 @@
-import { createMemo, createSignal } from "solid-js"
-import { useLocal } from "@tui/context/local"
-import { useSync } from "@tui/context/sync"
-import { map, pipe, entries, sortBy } from "remeda"
-import { DialogSelect, type DialogSelectRef, type DialogSelectOption } from "@tui/ui/dialog-select"
-import { useTheme } from "../context/theme"
-import { Keybind } from "@/util/keybind"
-import { TextAttributes } from "@opentui/core"
-import { useSDK } from "@tui/context/sdk"
-
-function Status(props: { enabled: boolean; loading: boolean }) {
-  const { theme } = useTheme()
-  if (props.loading) {
-    return <span style={{ fg: theme.textMuted }}>⋯ Loading</span>
-  }
-  if (props.enabled) {
-    return <span style={{ fg: theme.success, attributes: TextAttributes.BOLD }}>✓ Enabled</span>
-  }
-  return <span style={{ fg: theme.textMuted }}>○ Disabled</span>
-}
-
-export function DialogMcp() {
-  const local = useLocal()
-  const sync = useSync()
-  const sdk = useSDK()
-  const [, setRef] = createSignal<DialogSelectRef<unknown>>()
-  const [loading, setLoading] = createSignal<string | null>(null)
-
-  const options = createMemo(() => {
-    // Track sync data and loading state to trigger re-render when they change
-    const mcpData = sync.data.mcp
-    const loadingMcp = loading()
-
-    return pipe(
-      mcpData ?? {},
-      entries(),
-      sortBy(([name]) => name),
-      map(([name, status]) => ({
-        value: name,
-        title: name,
-        description: status.status === "failed" ? "failed" : status.status,
-        footer: <Status enabled={local.mcp.isEnabled(name)} loading={loadingMcp === name} />,
-        category: undefined,
-      })),
-    )
-  })
-
-  const keybinds = createMemo(() => [
-    {
-      keybind: Keybind.parse("space")[0],
-      title: "toggle",
-      onTrigger: async (option: DialogSelectOption<string>) => {
-        // Prevent toggling while an operation is already in progress
-        if (loading() !== null) return
-
-        setLoading(option.value)
-        try {
-          await local.mcp.toggle(option.value)
-          // Refresh MCP status from server
-          const status = await sdk.client.mcp.status()
-          if (status.data) {
-            sync.set("mcp", status.data)
-          } else {
-            console.error("Failed to refresh MCP status: no data returned")
-          }
-        } catch (error) {
-          console.error("Failed to toggle MCP:", error)
-        } finally {
-          setLoading(null)
-        }
-      },
-    },
-  ])
-
-  return (
-    <DialogSelect
-      ref={setRef}
-      title="MCPs"
-      options={options()}
-      keybind={keybinds()}
-      onSelect={(option) => {
-        // Don't close on select, only on escape
-      }}
-    />
-  )
-}