@vikasitai/vikasit-code 2.0.7 → 2.0.8

package/src/hook/index.ts

@@ -1,132 +0,0 @@
-import { Effect, Layer, ServiceMap } from "effect"
-import { HookSchema } from "./schema"
-import { Config } from "../config/config"
-import { Log } from "../util/log"
-import { exec } from "child_process"
-
-export namespace Hook {
-  const log = Log.create({ service: "hook" })
-
-  export interface HookContext {
-    event: HookSchema.HookEvent
-    tool?: string
-    args?: Record<string, any>
-    result?: any
-    file?: string
-    sessionID?: string
-    [key: string]: any
-  }
-
-  export interface Interface {
-    readonly fire: (event: HookSchema.HookEvent, context: HookContext) => Effect.Effect<HookSchema.HookResponse>
-  }
-
-  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/Hook") {}
-
-  export const layer: Layer.Layer<Service, never, Config.Service> = Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const config = yield* Config.Service
-
-      function matchesHook(hook: HookSchema.HookConfig, context: HookContext): boolean {
-        if (hook.event !== context.event) return false
-        if (!hook.matcher) return true
-
-        const pattern = hook.matcher.toLowerCase()
-        // Match against tool name
-        if (context.tool && globMatch(pattern, context.tool.toLowerCase())) return true
-        // Match against file path
-        if (context.file && globMatch(pattern, context.file.toLowerCase())) return true
-        return false
-      }
-
-      function globMatch(pattern: string, value: string): boolean {
-        if (pattern === "*") return true
-        if (pattern === value) return true
-        if (pattern.endsWith("*") && value.startsWith(pattern.slice(0, -1))) return true
-        if (pattern.startsWith("*") && value.endsWith(pattern.slice(1))) return true
-        return value.includes(pattern)
-      }
-
-      async function executeCommand(
-        command: string,
-        context: HookContext,
-        timeout: number,
-      ): Promise<HookSchema.HookResponse> {
-        return new Promise((resolve) => {
-          const env = {
-            ...process.env,
-            HOOK_EVENT: context.event,
-            HOOK_TOOL: context.tool ?? "",
-            HOOK_FILE: context.file ?? "",
-            HOOK_SESSION_ID: context.sessionID ?? "",
-            HOOK_CONTEXT: JSON.stringify(context),
-          }
-
-          exec(command, { timeout, env }, (error, stdout, stderr) => {
-            if (error) {
-              // Exit code 2 = blocking error
-              if (error.code === 2) {
-                resolve({
-                  continue: false,
-                  decision: "block",
-                  reason: stderr || stdout || "Hook blocked execution",
-                })
-                return
-              }
-              // Other errors are non-blocking
-              log.warn("Hook command failed", { command, error: error.message })
-              resolve({ continue: true })
-              return
-            }
-
-            // Try to parse JSON response from stdout
-            const trimmed = stdout.trim()
-            if (trimmed) {
-              try {
-                const parsed = HookSchema.HookResponse.parse(JSON.parse(trimmed))
-                resolve(parsed)
-                return
-              } catch {
-                // Non-JSON output is fine, treat as success
-              }
-            }
-
-            resolve({ continue: true })
-          })
-        })
-      }
-
-      const fire = Effect.fn("Hook.fire")(function* (event: HookSchema.HookEvent, context: HookContext) {
-        const cfg = yield* config.get()
-        const hooks = cfg.hooks ?? []
-
-        const matching = hooks.filter((h) => matchesHook(h, context))
-        if (matching.length === 0) {
-          return { continue: true } as HookSchema.HookResponse
-        }
-
-        // Execute all matching hooks
-        for (const hook of matching) {
-          const response = yield* Effect.promise(() => executeCommand(hook.command, context, hook.timeout ?? 10000))
-
-          // If any hook blocks, return immediately
-          if (response.decision === "block" || response.continue === false) {
-            return response
-          }
-
-          // If hook approves, skip further hooks for this event
-          if (response.decision === "approve") {
-            return response
-          }
-        }
-
-        return { continue: true } as HookSchema.HookResponse
-      })
-
-      return Service.of({ fire })
-    }),
-  )
-
-  export const defaultLayer = Layer.unwrap(Effect.sync(() => layer.pipe(Layer.provide(Config.defaultLayer))))
-}

package/src/hook/schema.ts

@@ -1,31 +0,0 @@
-import z from "zod"
-
-export namespace HookSchema {
-  export const HookEvent = z.enum([
-    "PreToolUse",
-    "PostToolUse",
-    "SessionStart",
-    "SessionEnd",
-    "FileChanged",
-    "SubagentStart",
-    "Notification",
-  ])
-  export type HookEvent = z.infer<typeof HookEvent>
-
-  export const HookResponse = z.object({
-    continue: z.boolean().optional().default(true),
-    suppressOutput: z.boolean().optional(),
-    decision: z.enum(["approve", "block"]).optional(),
-    reason: z.string().optional(),
-    additionalContext: z.string().optional(),
-  })
-  export type HookResponse = z.infer<typeof HookResponse>
-
-  export const HookConfig = z.object({
-    event: HookEvent,
-    matcher: z.string().optional().describe("Glob pattern to match tool name or file path"),
-    command: z.string().describe("Shell command to execute"),
-    timeout: z.number().optional().default(10000).describe("Timeout in milliseconds"),
-  })
-  export type HookConfig = z.infer<typeof HookConfig>
-}

package/src/id/id.ts

@@ -1,85 +0,0 @@
-import z from "zod"
-import { randomBytes } from "crypto"
-
-export namespace Identifier {
-  const prefixes = {
-    event: "evt",
-    session: "ses",
-    message: "msg",
-    permission: "per",
-    question: "que",
-    user: "usr",
-    part: "prt",
-    pty: "pty",
-    tool: "tool",
-    workspace: "wrk",
-  } as const
-
-  export function schema(prefix: keyof typeof prefixes) {
-    return z.string().startsWith(prefixes[prefix])
-  }
-
-  const LENGTH = 26
-
-  // State for monotonic ID generation
-  let lastTimestamp = 0
-  let counter = 0
-
-  export function ascending(prefix: keyof typeof prefixes, given?: string) {
-    return generateID(prefix, false, given)
-  }
-
-  export function descending(prefix: keyof typeof prefixes, given?: string) {
-    return generateID(prefix, true, given)
-  }
-
-  function generateID(prefix: keyof typeof prefixes, descending: boolean, given?: string): string {
-    if (!given) {
-      return create(prefix, descending)
-    }
-
-    if (!given.startsWith(prefixes[prefix])) {
-      throw new Error(`ID ${given} does not start with ${prefixes[prefix]}`)
-    }
-    return given
-  }
-
-  function randomBase62(length: number): string {
-    const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-    let result = ""
-    const bytes = randomBytes(length)
-    for (let i = 0; i < length; i++) {
-      result += chars[bytes[i] % 62]
-    }
-    return result
-  }
-
-  export function create(prefix: keyof typeof prefixes, descending: boolean, timestamp?: number): string {
-    const currentTimestamp = timestamp ?? Date.now()
-
-    if (currentTimestamp !== lastTimestamp) {
-      lastTimestamp = currentTimestamp
-      counter = 0
-    }
-    counter++
-
-    let now = BigInt(currentTimestamp) * BigInt(0x1000) + BigInt(counter)
-
-    now = descending ? ~now : now
-
-    const timeBytes = Buffer.alloc(6)
-    for (let i = 0; i < 6; i++) {
-      timeBytes[i] = Number((now >> BigInt(40 - 8 * i)) & BigInt(0xff))
-    }
-
-    return prefixes[prefix] + "_" + timeBytes.toString("hex") + randomBase62(LENGTH - 12)
-  }
-
-  /** Extract timestamp from an ascending ID. Does not work with descending IDs. */
-  export function timestamp(id: string): number {
-    const prefix = id.split("_")[0]
-    const hex = id.slice(prefix.length + 1, prefix.length + 13)
-    const encoded = BigInt("0x" + hex)
-    return Number(encoded / BigInt(0x1000))
-  }
-}

package/src/ide/index.ts

@@ -1,74 +0,0 @@
-import { BusEvent } from "@/bus/bus-event"
-import { Bus } from "@/bus"
-import z from "zod"
-import { NamedError } from "@vikasitai/util/error"
-import { Log } from "../util/log"
-import { Process } from "@/util/process"
-
-const SUPPORTED_IDES = [
-  { name: "Windsurf" as const, cmd: "windsurf" },
-  { name: "Visual Studio Code - Insiders" as const, cmd: "code-insiders" },
-  { name: "Visual Studio Code" as const, cmd: "code" },
-  { name: "Cursor" as const, cmd: "cursor" },
-  { name: "VSCodium" as const, cmd: "codium" },
-]
-
-export namespace Ide {
-  const log = Log.create({ service: "ide" })
-
-  export const Event = {
-    Installed: BusEvent.define(
-      "ide.installed",
-      z.object({
-        ide: z.string(),
-      }),
-    ),
-  }
-
-  export const AlreadyInstalledError = NamedError.create("AlreadyInstalledError", z.object({}))
-
-  export const InstallFailedError = NamedError.create(
-    "InstallFailedError",
-    z.object({
-      stderr: z.string(),
-    }),
-  )
-
-  export function ide() {
-    if (process.env["TERM_PROGRAM"] === "vscode") {
-      const v = process.env["GIT_ASKPASS"]
-      for (const ide of SUPPORTED_IDES) {
-        if (v?.includes(ide.name)) return ide.name
-      }
-    }
-    return "unknown"
-  }
-
-  export function alreadyInstalled() {
-    return process.env["VIKASIT_CALLER"] === "vscode" || process.env["VIKASIT_CALLER"] === "vscode-insiders"
-  }
-
-  export async function install(ide: (typeof SUPPORTED_IDES)[number]["name"]) {
-    const cmd = SUPPORTED_IDES.find((i) => i.name === ide)?.cmd
-    if (!cmd) throw new Error(`Unknown IDE: ${ide}`)
-
-    const p = await Process.run([cmd, "--install-extension", "vikasit-ai.vikasit-code"], {
-      nothrow: true,
-    })
-    const stdout = p.stdout.toString()
-    const stderr = p.stderr.toString()
-
-    log.info("installed", {
-      ide,
-      stdout,
-      stderr,
-    })
-
-    if (p.code !== 0) {
-      throw new InstallFailedError({ stderr })
-    }
-    if (stdout.includes("already installed")) {
-      throw new AlreadyInstalledError({})
-    }
-  }
-}

package/src/index.ts

@@ -1,249 +0,0 @@
-import yargs from "yargs"
-import { hideBin } from "yargs/helpers"
-import { RunCommand } from "./cli/cmd/run"
-import { GenerateCommand } from "./cli/cmd/generate"
-import { Log } from "./util/log"
-import { ConsoleCommand } from "./cli/cmd/account"
-import { ProvidersCommand } from "./cli/cmd/providers"
-import { AgentCommand } from "./cli/cmd/agent"
-import { UpgradeCommand } from "./cli/cmd/upgrade"
-import { UninstallCommand } from "./cli/cmd/uninstall"
-import { ModelsCommand } from "./cli/cmd/models"
-import { UI } from "./cli/ui"
-import { Installation } from "./installation"
-import { NamedError } from "@vikasitai/util/error"
-import { FormatError } from "./cli/error"
-import { ServeCommand } from "./cli/cmd/serve"
-import { Filesystem } from "./util/filesystem"
-import { DebugCommand } from "./cli/cmd/debug"
-import { StatsCommand } from "./cli/cmd/stats"
-import { McpCommand } from "./cli/cmd/mcp"
-import { GithubCommand } from "./cli/cmd/github"
-import { ExportCommand } from "./cli/cmd/export"
-import { ImportCommand } from "./cli/cmd/import"
-import { AttachCommand } from "./cli/cmd/tui/attach"
-import { TuiThreadCommand } from "./cli/cmd/tui/thread"
-import { AcpCommand } from "./cli/cmd/acp"
-import { EOL } from "os"
-import { WebCommand } from "./cli/cmd/web"
-import { PrCommand } from "./cli/cmd/pr"
-import { SessionCommand } from "./cli/cmd/session"
-import { DbCommand } from "./cli/cmd/db"
-import path from "path"
-import { Global } from "./global"
-import { JsonMigration } from "./storage/json-migration"
-import { Database } from "./storage/db"
-import { errorMessage } from "./util/error"
-import { PluginCommand } from "./cli/cmd/plug"
-
-process.on("unhandledRejection", (e) => {
-  Log.Default.error("rejection", {
-    e: errorMessage(e),
-  })
-})
-
-process.on("uncaughtException", (e) => {
-  Log.Default.error("exception", {
-    e: errorMessage(e),
-  })
-})
-
-const cli = yargs(hideBin(process.argv))
-  .parserConfiguration({ "populate--": true })
-  .scriptName("vikasit")
-  .wrap(100)
-  .help("help", "show help")
-  .alias("help", "h")
-  .version("version", "show version number", Installation.VERSION)
-  .alias("version", "v")
-  .option("print-logs", {
-    describe: "print logs to stderr",
-    type: "boolean",
-  })
-  .option("log-level", {
-    describe: "log level",
-    type: "string",
-    choices: ["DEBUG", "INFO", "WARN", "ERROR"],
-  })
-  .option("pure", {
-    describe: "run without external plugins",
-    type: "boolean",
-  })
-  .middleware(async (opts) => {
-    if (opts.pure) {
-      process.env.VIKASIT_PURE = "1"
-    }
-
-    // Auto-detect default model based on API key's allowed models
-    const apiKey = process.env["VIKASIT_API_KEY"]
-    if (apiKey && !opts.model) {
-      const fs = await import("fs")
-      const path = await import("path")
-      const os = await import("os")
-      const configDir = path.join(os.homedir(), ".config", "vikasit")
-      const configPath = path.join(configDir, "vikasit.json")
-      let hasModel = false
-      try { hasModel = !!JSON.parse(fs.readFileSync(configPath, "utf-8")).model } catch {}
-
-      if (!hasModel) {
-        try {
-          const res = await fetch("https://api.vikasit.ai/v1/models", {
-            headers: { Authorization: `Bearer ${apiKey}` },
-            signal: AbortSignal.timeout(5000),
-          })
-          if (res.ok) {
-            const data = (await res.json()) as { data?: Array<{ id: string }> }
-            const models = new Set((data.data || []).map((m: { id: string }) => m.id))
-            let model = "vikasit-3-small"
-            if (models.has("vikasit-3-fast")) model = "vikasit-3-fast"
-            fs.mkdirSync(configDir, { recursive: true })
-            let cfg: Record<string, unknown> = {}
-            try { cfg = JSON.parse(fs.readFileSync(configPath, "utf-8")) } catch {}
-            cfg.model = `vikasit-ai/${model}`
-            fs.writeFileSync(configPath, JSON.stringify(cfg, null, 2))
-          }
-        } catch {}
-      }
-    }
-
-    await Log.init({
-      print: process.argv.includes("--print-logs"),
-      dev: Installation.isLocal(),
-      level: (() => {
-        if (opts.logLevel) return opts.logLevel as Log.Level
-        if (Installation.isLocal()) return "DEBUG"
-        return "INFO"
-      })(),
-    })
-
-    process.env.AGENT = "1"
-    process.env.OPENCODE = "1"
-    process.env.VIKASIT_PID = String(process.pid)
-
-    Log.Default.info("vikasit", {
-      version: Installation.VERSION,
-      args: process.argv.slice(2),
-    })
-
-    const marker = path.join(Global.Path.data, "vikasit.db")
-    if (!(await Filesystem.exists(marker))) {
-      const tty = process.stderr.isTTY
-      process.stderr.write("Performing one time database migration, may take a few minutes..." + EOL)
-      const width = 36
-      const orange = "\x1b[38;5;214m"
-      const muted = "\x1b[0;2m"
-      const reset = "\x1b[0m"
-      let last = -1
-      if (tty) process.stderr.write("\x1b[?25l")
-      try {
-        await JsonMigration.run(Database.Client().$client, {
-          progress: (event) => {
-            const percent = Math.floor((event.current / event.total) * 100)
-            if (percent === last && event.current !== event.total) return
-            last = percent
-            if (tty) {
-              const fill = Math.round((percent / 100) * width)
-              const bar = `${"■".repeat(fill)}${"･".repeat(width - fill)}`
-              process.stderr.write(
-                `\r${orange}${bar} ${percent.toString().padStart(3)}%${reset} ${muted}${event.label.padEnd(12)} ${event.current}/${event.total}${reset}`,
-              )
-              if (event.current === event.total) process.stderr.write("\n")
-            } else {
-              process.stderr.write(`sqlite-migration:${percent}${EOL}`)
-            }
-          },
-        })
-      } finally {
-        if (tty) process.stderr.write("\x1b[?25h")
-        else {
-          process.stderr.write(`sqlite-migration:done${EOL}`)
-        }
-      }
-      process.stderr.write("Database migration complete." + EOL)
-    }
-  })
-  .usage("\n" + UI.logo())
-  .completion("completion", "generate shell completion script")
-  .command(AcpCommand)
-  .command(McpCommand)
-  .command(TuiThreadCommand)
-  .command(AttachCommand)
-  .command(RunCommand)
-  .command(GenerateCommand)
-  .command(DebugCommand)
-  .command(ConsoleCommand)
-  .command(ProvidersCommand)
-  .command(AgentCommand)
-  .command(UpgradeCommand)
-  .command(UninstallCommand)
-  .command(ServeCommand)
-  .command(WebCommand)
-  .command(ModelsCommand)
-  .command(StatsCommand)
-  .command(ExportCommand)
-  .command(ImportCommand)
-  .command(GithubCommand)
-  .command(PrCommand)
-  .command(SessionCommand)
-  .command(PluginCommand)
-  .command(DbCommand)
-  .fail((msg, err) => {
-    if (
-      msg?.startsWith("Unknown argument") ||
-      msg?.startsWith("Not enough non-option arguments") ||
-      msg?.startsWith("Invalid values:")
-    ) {
-      if (err) throw err
-      cli.showHelp("log")
-    }
-    if (err) throw err
-    process.exit(1)
-  })
-  .strict()
-
-try {
-  await cli.parse()
-} catch (e) {
-  let data: Record<string, any> = {}
-  if (e instanceof NamedError) {
-    const obj = e.toObject()
-    Object.assign(data, {
-      ...obj.data,
-    })
-  }
-
-  if (e instanceof Error) {
-    Object.assign(data, {
-      name: e.name,
-      message: e.message,
-      cause: e.cause?.toString(),
-      stack: e.stack,
-    })
-  }
-
-  if (e instanceof ResolveMessage) {
-    Object.assign(data, {
-      name: e.name,
-      message: e.message,
-      code: e.code,
-      specifier: e.specifier,
-      referrer: e.referrer,
-      position: e.position,
-      importKind: e.importKind,
-    })
-  }
-  Log.Default.error("fatal", data)
-  const formatted = FormatError(e)
-  if (formatted) UI.error(formatted)
-  if (formatted === undefined) {
-    UI.error("Unexpected error, check log file at " + Log.file() + " for more details" + EOL)
-    process.stderr.write(errorMessage(e) + EOL)
-  }
-  process.exitCode = 1
-} finally {
-  // Some subprocesses don't react properly to SIGTERM and similar signals.
-  // Most notably, some docker-container-based MCP servers don't handle such signals unless
-  // run using `docker run --init`.
-  // Explicitly exit to avoid any hanging subprocesses.
-  process.exit()
-}