@vikasitai/vikasit-code 2.0.4 → 2.0.6

package/src/hook/index.ts

@@ -0,0 +1,132 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,85 @@
+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

@@ -0,0 +1,74 @@
+import { BusEvent } from "@/bus/bus-event"
+import { Bus } from "@/bus"
+import z from "zod"
+import { NamedError } from "@vikasit-code/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

@@ -0,0 +1,249 @@
+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 "@vikasit-code/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()
+}