nikcli 0.0.6

package/src/pty/index.ts

@@ -0,0 +1,241 @@
+import { BusEvent } from "@/bus/bus-event"
+import { Bus } from "@/bus"
+import { type IPty } from "bun-pty"
+import z from "zod"
+import { Identifier } from "../id/id"
+import { Log } from "../util/log"
+import type { WSContext } from "hono/ws"
+import { Instance } from "../project/instance"
+import { lazy } from "@nikcli-ai/util/lazy"
+import { Shell } from "@/shell/shell"
+
+export namespace Pty {
+  const log = Log.create({ service: "pty" })
+
+  const BUFFER_LIMIT = 1024 * 1024 * 2
+  const BUFFER_CHUNK = 64 * 1024
+
+  const pty = lazy(async () => {
+    const { spawn } = await import("bun-pty")
+    return spawn
+  })
+
+  export const Info = z
+    .object({
+      id: Identifier.schema("pty"),
+      title: z.string(),
+      command: z.string(),
+      args: z.array(z.string()),
+      cwd: z.string(),
+      status: z.enum(["running", "exited"]),
+      pid: z.number(),
+    })
+    .meta({ ref: "Pty" })
+
+  export type Info = z.infer<typeof Info>
+
+  export const CreateInput = z.object({
+    command: z.string().optional(),
+    args: z.array(z.string()).optional(),
+    cwd: z.string().optional(),
+    title: z.string().optional(),
+    env: z.record(z.string(), z.string()).optional(),
+  })
+
+  export type CreateInput = z.infer<typeof CreateInput>
+
+  export const UpdateInput = z.object({
+    title: z.string().optional(),
+    size: z
+      .object({
+        rows: z.number(),
+        cols: z.number(),
+      })
+      .optional(),
+  })
+
+  export type UpdateInput = z.infer<typeof UpdateInput>
+
+  export const Event = {
+    Created: BusEvent.define("pty.created", z.object({ info: Info })),
+    Updated: BusEvent.define("pty.updated", z.object({ info: Info })),
+    Exited: BusEvent.define("pty.exited", z.object({ id: Identifier.schema("pty"), exitCode: z.number() })),
+    Deleted: BusEvent.define("pty.deleted", z.object({ id: Identifier.schema("pty") })),
+  }
+
+  interface ActiveSession {
+    info: Info
+    process: IPty
+    buffer: string
+    subscribers: Set<WSContext>
+  }
+
+  const state = Instance.state(
+    () => new Map<string, ActiveSession>(),
+    async (sessions) => {
+      for (const session of sessions.values()) {
+        try {
+          session.process.kill()
+        } catch {}
+        for (const ws of session.subscribers) {
+          ws.close()
+        }
+      }
+      sessions.clear()
+    },
+  )
+
+  export function list() {
+    return Array.from(state().values()).map((s) => s.info)
+  }
+
+  export function get(id: string) {
+    return state().get(id)?.info
+  }
+
+  export async function create(input: CreateInput) {
+    const id = Identifier.create("pty", false)
+    const command = input.command || Shell.preferred()
+    const args = input.args || []
+    if (command.endsWith("sh")) {
+      args.push("-l")
+    }
+
+    const cwd = input.cwd || Instance.directory
+    const env = {
+      ...process.env,
+      ...input.env,
+      TERM: "xterm-256color",
+      NIKCLI_TERMINAL: "1",
+    } as Record<string, string>
+    log.info("creating session", { id, cmd: command, args, cwd })
+
+    const spawn = await pty()
+    const ptyProcess = spawn(command, args, {
+      name: "xterm-256color",
+      cwd,
+      env,
+    })
+
+    const info = {
+      id,
+      title: input.title || `Terminal ${id.slice(-4)}`,
+      command,
+      args,
+      cwd,
+      status: "running",
+      pid: ptyProcess.pid,
+    } as const
+    const session: ActiveSession = {
+      info,
+      process: ptyProcess,
+      buffer: "",
+      subscribers: new Set(),
+    }
+    state().set(id, session)
+    ptyProcess.onData((data) => {
+      let open = false
+      for (const ws of session.subscribers) {
+        if (ws.readyState !== 1) {
+          session.subscribers.delete(ws)
+          continue
+        }
+        open = true
+        ws.send(data)
+      }
+      if (open) return
+      session.buffer += data
+      if (session.buffer.length <= BUFFER_LIMIT) return
+      session.buffer = session.buffer.slice(-BUFFER_LIMIT)
+    })
+    ptyProcess.onExit(({ exitCode }) => {
+      log.info("session exited", { id, exitCode })
+      session.info.status = "exited"
+      for (const ws of session.subscribers) {
+        ws.close()
+      }
+      session.subscribers.clear()
+      Bus.publish(Event.Exited, { id, exitCode })
+      for (const ws of session.subscribers) {
+        ws.close()
+      }
+      state().delete(id)
+    })
+    Bus.publish(Event.Created, { info })
+    return info
+  }
+
+  export async function update(id: string, input: UpdateInput) {
+    const session = state().get(id)
+    if (!session) return
+    if (input.title) {
+      session.info.title = input.title
+    }
+    if (input.size) {
+      session.process.resize(input.size.cols, input.size.rows)
+    }
+    Bus.publish(Event.Updated, { info: session.info })
+    return session.info
+  }
+
+  export async function remove(id: string) {
+    const session = state().get(id)
+    if (!session) return
+    log.info("removing session", { id })
+    try {
+      session.process.kill()
+    } catch {}
+    for (const ws of session.subscribers) {
+      ws.close()
+    }
+    state().delete(id)
+    Bus.publish(Event.Deleted, { id })
+  }
+
+  export function resize(id: string, cols: number, rows: number) {
+    const session = state().get(id)
+    if (session && session.info.status === "running") {
+      session.process.resize(cols, rows)
+    }
+  }
+
+  export function write(id: string, data: string) {
+    const session = state().get(id)
+    if (session && session.info.status === "running") {
+      session.process.write(data)
+    }
+  }
+
+  export function connect(id: string, ws: WSContext) {
+    const session = state().get(id)
+    if (!session) {
+      ws.close()
+      return
+    }
+    log.info("client connected to session", { id })
+    session.subscribers.add(ws)
+    if (session.buffer) {
+      const buffer = session.buffer.length <= BUFFER_LIMIT ? session.buffer : session.buffer.slice(-BUFFER_LIMIT)
+      session.buffer = ""
+      try {
+        for (let i = 0; i < buffer.length; i += BUFFER_CHUNK) {
+          ws.send(buffer.slice(i, i + BUFFER_CHUNK))
+        }
+      } catch {
+        session.subscribers.delete(ws)
+        session.buffer = buffer
+        ws.close()
+        return
+      }
+    }
+    return {
+      onMessage: (message: string | ArrayBuffer) => {
+        session.process.write(String(message))
+      },
+      onClose: () => {
+        log.info("client disconnected from session", { id })
+        session.subscribers.delete(ws)
+      },
+    }
+  }
+}

package/src/question/index.ts

@@ -0,0 +1,171 @@
+import { Bus } from "@/bus"
+import { BusEvent } from "@/bus/bus-event"
+import { Identifier } from "@/id/id"
+import { Instance } from "@/project/instance"
+import { Log } from "@/util/log"
+import z from "zod"
+
+export namespace Question {
+  const log = Log.create({ service: "question" })
+
+  export const Option = z
+    .object({
+      label: z.string().max(30).describe("Display text (1-5 words, concise)"),
+      description: z.string().describe("Explanation of choice"),
+    })
+    .meta({
+      ref: "QuestionOption",
+    })
+  export type Option = z.infer<typeof Option>
+
+  export const Info = z
+    .object({
+      question: z.string().describe("Complete question"),
+      header: z.string().max(30).describe("Very short label (max 30 chars)"),
+      options: z.array(Option).describe("Available choices"),
+      multiple: z.boolean().optional().describe("Allow selecting multiple choices"),
+      custom: z.boolean().optional().describe("Allow typing a custom answer (default: true)"),
+    })
+    .meta({
+      ref: "QuestionInfo",
+    })
+  export type Info = z.infer<typeof Info>
+
+  export const Request = z
+    .object({
+      id: Identifier.schema("question"),
+      sessionID: Identifier.schema("session"),
+      questions: z.array(Info).describe("Questions to ask"),
+      tool: z
+        .object({
+          messageID: z.string(),
+          callID: z.string(),
+        })
+        .optional(),
+    })
+    .meta({
+      ref: "QuestionRequest",
+    })
+  export type Request = z.infer<typeof Request>
+
+  export const Answer = z.array(z.string()).meta({
+    ref: "QuestionAnswer",
+  })
+  export type Answer = z.infer<typeof Answer>
+
+  export const Reply = z.object({
+    answers: z
+      .array(Answer)
+      .describe("User answers in order of questions (each answer is an array of selected labels)"),
+  })
+  export type Reply = z.infer<typeof Reply>
+
+  export const Event = {
+    Asked: BusEvent.define("question.asked", Request),
+    Replied: BusEvent.define(
+      "question.replied",
+      z.object({
+        sessionID: z.string(),
+        requestID: z.string(),
+        answers: z.array(Answer),
+      }),
+    ),
+    Rejected: BusEvent.define(
+      "question.rejected",
+      z.object({
+        sessionID: z.string(),
+        requestID: z.string(),
+      }),
+    ),
+  }
+
+  const state = Instance.state(async () => {
+    const pending: Record<
+      string,
+      {
+        info: Request
+        resolve: (answers: Answer[]) => void
+        reject: (e: any) => void
+      }
+    > = {}
+
+    return {
+      pending,
+    }
+  })
+
+  export async function ask(input: {
+    sessionID: string
+    questions: Info[]
+    tool?: { messageID: string; callID: string }
+  }): Promise<Answer[]> {
+    const s = await state()
+    const id = Identifier.ascending("question")
+
+    log.info("asking", { id, questions: input.questions.length })
+
+    return new Promise<Answer[]>((resolve, reject) => {
+      const info: Request = {
+        id,
+        sessionID: input.sessionID,
+        questions: input.questions,
+        tool: input.tool,
+      }
+      s.pending[id] = {
+        info,
+        resolve,
+        reject,
+      }
+      Bus.publish(Event.Asked, info)
+    })
+  }
+
+  export async function reply(input: { requestID: string; answers: Answer[] }): Promise<void> {
+    const s = await state()
+    const existing = s.pending[input.requestID]
+    if (!existing) {
+      log.warn("reply for unknown request", { requestID: input.requestID })
+      return
+    }
+    delete s.pending[input.requestID]
+
+    log.info("replied", { requestID: input.requestID, answers: input.answers })
+
+    Bus.publish(Event.Replied, {
+      sessionID: existing.info.sessionID,
+      requestID: existing.info.id,
+      answers: input.answers,
+    })
+
+    existing.resolve(input.answers)
+  }
+
+  export async function reject(requestID: string): Promise<void> {
+    const s = await state()
+    const existing = s.pending[requestID]
+    if (!existing) {
+      log.warn("reject for unknown request", { requestID })
+      return
+    }
+    delete s.pending[requestID]
+
+    log.info("rejected", { requestID })
+
+    Bus.publish(Event.Rejected, {
+      sessionID: existing.info.sessionID,
+      requestID: existing.info.id,
+    })
+
+    existing.reject(new RejectedError())
+  }
+
+  export class RejectedError extends Error {
+    constructor() {
+      super("The user dismissed this question")
+    }
+  }
+
+  export async function list() {
+    return state().then((x) => Object.values(x.pending).map((x) => x.info))
+  }
+}

package/src/rag/chunk.ts

@@ -0,0 +1,43 @@
+export type RagChunk = {
+  id: string
+  file: string
+  start: number
+  end: number
+  text: string
+}
+
+export type RagChunkResult = {
+  chunks: RagChunk[]
+  truncated: boolean
+}
+
+export function chunkText(input: {
+  file: string
+  text: string
+  chunkLines: number
+  maxChunks: number
+}): RagChunkResult {
+  const lines = input.text.split("\n")
+  const total = Math.ceil(lines.length / input.chunkLines)
+  const starts = Array.from({ length: total }, (_, index) => index * input.chunkLines)
+  const chunks = [] as RagChunk[]
+
+  for (const start of starts) {
+    if (chunks.length >= input.maxChunks) break
+    const end = Math.min(lines.length, start + input.chunkLines)
+    const text = lines.slice(start, end).join("\n")
+    const hash = Bun.hash.xxHash32(`${input.file}:${start + 1}:${end}`)
+    chunks.push({
+      id: `chunk_${hash}`,
+      file: input.file,
+      start: start + 1,
+      end,
+      text,
+    })
+  }
+
+  return {
+    chunks,
+    truncated: chunks.length < total,
+  }
+}

package/src/rag/embed.ts

@@ -0,0 +1,179 @@
+import { ModelsDev } from "@/provider/models"
+import { Auth } from "@/auth"
+import { Env } from "@/env"
+import { Log } from "@/util/log"
+import { Config } from "@/config/config"
+
+const BATCH_SIZE = 32
+
+type EmbeddingResponse = {
+  data: Array<{ embedding: number[]; index: number }>
+}
+
+type OllamaEmbeddingResponse = {
+  embedding: number[]
+}
+
+export namespace RagEmbed {
+  const log = Log.create({ service: "rag.embed" })
+
+  function normalizeBaseURL(baseURL: string): string {
+    return baseURL.endsWith("/") ? baseURL.slice(0, -1) : baseURL
+  }
+
+  function normalizeOllamaV1BaseURL(baseURL: string): string {
+    const url = normalizeBaseURL(baseURL)
+    if (url.endsWith("/v1")) return url
+    return `${url}/v1`
+  }
+
+  function ollamaRootFromV1BaseURL(baseURL: string): string {
+    const url = normalizeBaseURL(baseURL)
+    if (url.endsWith("/v1")) return url.slice(0, -3)
+    return url
+  }
+
+  async function resolveOllama() {
+    const config = await Config.get().catch(() => undefined)
+    const baseURL = normalizeOllamaV1BaseURL(
+      (config as any)?.provider?.ollama?.options?.baseURL ?? Env.get("OLLAMA_BASE_URL") ?? "http://127.0.0.1:11434/v1",
+    )
+
+    const auth = await Auth.get("ollama").catch(() => undefined)
+    const apiKey =
+      (config as any)?.provider?.ollama?.options?.apiKey ??
+      (auth && (auth as any).type === "api" ? (auth as any).key : undefined) ??
+      Env.get("OLLAMA_API_KEY") ??
+      "ollama"
+
+    return { baseURL, root: ollamaRootFromV1BaseURL(baseURL), apiKey }
+  }
+
+  export async function embedAll(texts: string[], model?: string, provider?: string) {
+    if (texts.length === 0) return [] as number[][]
+    const config = await Config.get().catch(() => undefined)
+    const chosen = model ?? config?.rag?.model
+    const chosenProvider = provider ?? config?.rag?.provider
+    if (!chosen || !chosenProvider) {
+      throw new Error(
+        `RAG model or provider not configured. Run 'nikcli rag-model <provider> <model>' to set embedding model.`,
+      )
+    }
+    const batches = Array.from({ length: Math.ceil(texts.length / BATCH_SIZE) }, (_, index) => {
+      const start = index * BATCH_SIZE
+      const end = start + BATCH_SIZE
+      return texts.slice(start, end)
+    })
+
+    const results: number[][] = []
+    for (const batch of batches) {
+      const embedded = await embedBatch(batch, chosen, chosenProvider)
+      results.push(...embedded)
+      if (batches.indexOf(batch) < batches.length - 1) {
+        await new Promise((resolve) => setTimeout(resolve, 1000))
+      }
+    }
+    return results
+  }
+
+  async function embedBatch(texts: string[], model: string, provider: string) {
+    if (provider === "ollama") {
+      return embedOllama(texts, model)
+    }
+
+    const { api, key } = await resolveProvider(provider)
+    const response = await fetch(`${api}/embeddings`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${key}`,
+      },
+      body: JSON.stringify({ model, input: texts }),
+    })
+
+    if (!response.ok) {
+      const body = await response.text().catch(() => "")
+      throw new Error(`Embedding request failed (${response.status}): ${body}`)
+    }
+
+    const json = (await response.json()) as EmbeddingResponse
+    if (!Array.isArray(json.data)) {
+      throw new Error(`Unexpected embedding response shape: ${JSON.stringify(json)}`)
+    }
+    const sorted = json.data.sort((a, b) => a.index - b.index)
+    return sorted.map((item) => item.embedding)
+  }
+
+  async function embedOllama(texts: string[], model: string) {
+    const { baseURL, root, apiKey } = await resolveOllama()
+
+    // Prefer OpenAI-compatible embeddings when available (matches OpenCode docs).
+    const openAiResponse = await fetch(`${baseURL}/embeddings`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify({ model, input: texts }),
+    }).catch(() => undefined)
+
+    if (openAiResponse?.ok) {
+      const json = (await openAiResponse.json()) as EmbeddingResponse
+      if (Array.isArray(json.data)) {
+        const sorted = json.data.sort((a, b) => a.index - b.index)
+        return sorted.map((item) => item.embedding)
+      }
+    }
+
+    // Fallback to legacy Ollama embeddings endpoint.
+    const results: number[][] = []
+    for (const text of texts) {
+      const truncated = text.slice(0, 500)
+      const response = await fetch(`${root}/api/embeddings`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ model, prompt: truncated }),
+      })
+
+      if (!response.ok) {
+        const body = await response.text().catch(() => "")
+        throw new Error(`Ollama embedding failed (${response.status}): ${body}`)
+      }
+
+      const json = (await response.json()) as OllamaEmbeddingResponse
+      results.push(json.embedding)
+    }
+    return results
+  }
+
+  const KNOWN_PROVIDER_APIS: Record<string, string> = {
+    openrouter: "https://openrouter.ai/api/v1",
+    openai: "https://api.openai.com/v1",
+    anthropic: "https://api.anthropic.com/v1",
+    google: "https://generativelanguage.googleapis.com/v1beta/openai",
+    mistral: "https://api.mistral.ai/v1",
+    together: "https://api.together.xyz/v1",
+    groq: "https://api.groq.com/openai/v1",
+    cohere: "https://api.cohere.ai/v1",
+    nvidia: "https://integrate.api.nvidia.com/v1",
+    voyage: "https://api.voyageai.com/v1",
+  }
+
+  async function resolveProvider(providerID: string) {
+    const auth = await Auth.get(providerID)
+    const key = auth?.type === "api" ? auth.key : Env.get(`${providerID.toUpperCase()}_API_KEY`)
+    if (!key) {
+      throw new Error(`Missing ${providerID} API key. Run \`nikcli auth login\` for provider ${providerID}.`)
+    }
+
+    const database = await ModelsDev.get()
+    const provider = database[providerID]
+    const api = provider?.api ?? KNOWN_PROVIDER_APIS[providerID]
+    if (!api) {
+      log.error("provider missing api", { provider: providerID })
+      throw new Error(`${providerID} provider configuration not found. Set rag.provider to a supported provider.`)
+    }
+
+    return { api, key }
+  }
+}