nikcli 0.0.6

package/src/project/state.ts

@@ -0,0 +1,66 @@
+import { Log } from "@/util/log"
+
+export namespace State {
+  interface Entry {
+    state: any
+    dispose?: (state: any) => Promise<void>
+  }
+
+  const log = Log.create({ service: "state" })
+  const recordsByKey = new Map<string, Map<any, Entry>>()
+
+  export function create<S>(root: () => string, init: () => S, dispose?: (state: Awaited<S>) => Promise<void>) {
+    return () => {
+      const key = root()
+      let entries = recordsByKey.get(key)
+      if (!entries) {
+        entries = new Map<string, Entry>()
+        recordsByKey.set(key, entries)
+      }
+      const exists = entries.get(init)
+      if (exists) return exists.state as S
+      const state = init()
+      entries.set(init, {
+        state,
+        dispose,
+      })
+      return state
+    }
+  }
+
+  export async function dispose(key: string) {
+    const entries = recordsByKey.get(key)
+    if (!entries) return
+
+    log.info("waiting for state disposal to complete", { key })
+
+    let disposalFinished = false
+
+    setTimeout(() => {
+      if (!disposalFinished) {
+        log.warn(
+          "state disposal is taking an unusually long time - if it does not complete in a reasonable time, please report this as a bug",
+          { key },
+        )
+      }
+    }, 10000).unref()
+
+    const tasks: Promise<void>[] = []
+    for (const entry of entries.values()) {
+      if (!entry.dispose) continue
+
+      const task = Promise.resolve(entry.state)
+        .then((state) => entry.dispose!(state))
+        .catch((error) => {
+          log.error("Error while disposing state:", { error, key })
+        })
+
+      tasks.push(task)
+    }
+    entries.clear()
+    recordsByKey.delete(key)
+    await Promise.all(tasks)
+    disposalFinished = true
+    log.info("state disposal completed", { key })
+  }
+}

package/src/project/vcs.ts

@@ -0,0 +1,76 @@
+import { BusEvent } from "@/bus/bus-event"
+import { Bus } from "@/bus"
+import { $ } from "bun"
+import path from "path"
+import z from "zod"
+import { Log } from "@/util/log"
+import { Instance } from "./instance"
+import { FileWatcher } from "@/file/watcher"
+
+const log = Log.create({ service: "vcs" })
+
+export namespace Vcs {
+  export const Event = {
+    BranchUpdated: BusEvent.define(
+      "vcs.branch.updated",
+      z.object({
+        branch: z.string().optional(),
+      }),
+    ),
+  }
+
+  export const Info = z
+    .object({
+      branch: z.string(),
+    })
+    .meta({
+      ref: "VcsInfo",
+    })
+  export type Info = z.infer<typeof Info>
+
+  async function currentBranch() {
+    return $`git rev-parse --abbrev-ref HEAD`
+      .quiet()
+      .nothrow()
+      .cwd(Instance.worktree)
+      .text()
+      .then((x) => x.trim())
+      .catch(() => undefined)
+  }
+
+  const state = Instance.state(
+    async () => {
+      if (Instance.project.vcs !== "git") {
+        return { branch: async () => undefined, unsubscribe: undefined }
+      }
+      let current = await currentBranch()
+      log.info("initialized", { branch: current })
+
+      const unsubscribe = Bus.subscribe(FileWatcher.Event.Updated, async (evt) => {
+        if (evt.properties.file.endsWith("HEAD")) return
+        const next = await currentBranch()
+        if (next !== current) {
+          log.info("branch changed", { from: current, to: next })
+          current = next
+          Bus.publish(Event.BranchUpdated, { branch: next })
+        }
+      })
+
+      return {
+        branch: async () => current,
+        unsubscribe,
+      }
+    },
+    async (state) => {
+      state.unsubscribe?.()
+    },
+  )
+
+  export async function init() {
+    return state()
+  }
+
+  export async function branch() {
+    return await state().then((s) => s.branch())
+  }
+}

package/src/prompt/stash-store.ts

@@ -0,0 +1,93 @@
+import path from "path"
+import { appendFile, writeFile } from "fs/promises"
+import { Global } from "@/global"
+import type { PromptInfo } from "@/cli/cmd/tui/component/prompt/history"
+
+export type StashEntry = {
+  id: string
+  input: string
+  parts: PromptInfo["parts"]
+  timestamp: number
+}
+
+const MAX_STASH_ENTRIES = 50
+let writeQueue = Promise.resolve()
+
+function filePath() {
+  return path.join(Global.Path.state, "prompt-stash.jsonl")
+}
+
+async function read() {
+  const text = await Bun.file(filePath())
+    .text()
+    .catch(() => "")
+  return text
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line) as Partial<StashEntry>
+      } catch {
+        return null
+      }
+    })
+    .filter((line): line is Partial<StashEntry> => line !== null)
+    .map((entry) => ({
+      id: typeof entry.id === "string" && entry.id ? entry.id : String(entry.timestamp ?? Date.now()),
+      input: typeof entry.input === "string" ? entry.input : "",
+      parts: Array.isArray(entry.parts) ? (entry.parts as PromptInfo["parts"]) : [],
+      timestamp: typeof entry.timestamp === "number" ? entry.timestamp : Date.now(),
+    }))
+    .slice(-MAX_STASH_ENTRIES)
+}
+
+async function rewrite(entries: StashEntry[]) {
+  const content = entries.length ? `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n` : ""
+  await writeFile(filePath(), content)
+}
+
+function enqueue<T>(fn: () => Promise<T>) {
+  const next = writeQueue.then(fn)
+  writeQueue = next.then(
+    () => undefined,
+    () => undefined,
+  )
+  return next
+}
+
+export namespace PromptStashStore {
+  export async function list() {
+    return read()
+  }
+
+  export async function push(entry: Omit<StashEntry, "id" | "timestamp"> & { id?: string; timestamp?: number }) {
+    return enqueue(async () => {
+      const current = await read()
+      const next: StashEntry = {
+        id: entry.id ?? `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        input: entry.input,
+        parts: entry.parts,
+        timestamp: entry.timestamp ?? Date.now(),
+      }
+      const entries = [...current, next].slice(-MAX_STASH_ENTRIES)
+      if (current.length + 1 === entries.length) {
+        await appendFile(filePath(), `${JSON.stringify(next)}\n`).catch(async () => {
+          await rewrite(entries)
+        })
+      } else {
+        await rewrite(entries)
+      }
+      return entries
+    })
+  }
+
+  export async function removeByID(id: string) {
+    return enqueue(async () => {
+      const current = await read()
+      const next = current.filter((entry) => entry.id !== id)
+      if (next.length === current.length) return current
+      await rewrite(next)
+      return next
+    })
+  }
+}

package/src/provider/auth.ts

@@ -0,0 +1,147 @@
+import { Instance } from "@/project/instance"
+import { Plugin } from "../plugin"
+import { map, filter, pipe, fromEntries, mapValues } from "remeda"
+import z from "zod"
+import { fn } from "@/util/fn"
+import type { AuthOuathResult, Hooks } from "@nikcli-ai/plugin"
+import { NamedError } from "@nikcli-ai/util/error"
+import { Auth } from "@/auth"
+
+export namespace ProviderAuth {
+  const state = Instance.state(async () => {
+    const methods = pipe(
+      await Plugin.list(),
+      filter((x) => x.auth?.provider !== undefined),
+      map((x) => [x.auth!.provider, x.auth!] as const),
+      fromEntries(),
+    )
+    return { methods, pending: {} as Record<string, AuthOuathResult> }
+  })
+
+  export const Method = z
+    .object({
+      type: z.union([z.literal("oauth"), z.literal("api")]),
+      label: z.string(),
+    })
+    .meta({
+      ref: "ProviderAuthMethod",
+    })
+  export type Method = z.infer<typeof Method>
+
+  export async function methods() {
+    const s = await state().then((x) => x.methods)
+    return mapValues(s, (x) =>
+      x.methods.map(
+        (y): Method => ({
+          type: y.type,
+          label: y.label,
+        }),
+      ),
+    )
+  }
+
+  export const Authorization = z
+    .object({
+      url: z.string(),
+      method: z.union([z.literal("auto"), z.literal("code")]),
+      instructions: z.string(),
+    })
+    .meta({
+      ref: "ProviderAuthAuthorization",
+    })
+  export type Authorization = z.infer<typeof Authorization>
+
+  export const authorize = fn(
+    z.object({
+      providerID: z.string(),
+      method: z.number(),
+    }),
+    async (input): Promise<Authorization | undefined> => {
+      const auth = await state().then((s) => s.methods[input.providerID])
+      const method = auth.methods[input.method]
+      if (method.type === "oauth") {
+        const result = await method.authorize()
+        await state().then((s) => (s.pending[input.providerID] = result))
+        return {
+          url: result.url,
+          method: result.method,
+          instructions: result.instructions,
+        }
+      }
+    },
+  )
+
+  export const callback = fn(
+    z.object({
+      providerID: z.string(),
+      method: z.number(),
+      code: z.string().optional(),
+    }),
+    async (input) => {
+      const match = await state().then((s) => s.pending[input.providerID])
+      if (!match) throw new OauthMissing({ providerID: input.providerID })
+      let result
+
+      if (match.method === "code") {
+        if (!input.code) throw new OauthCodeMissing({ providerID: input.providerID })
+        result = await match.callback(input.code)
+      }
+
+      if (match.method === "auto") {
+        result = await match.callback()
+      }
+
+      if (result?.type === "success") {
+        if ("key" in result) {
+          await Auth.set(input.providerID, {
+            type: "api",
+            key: result.key,
+          })
+        }
+        if ("refresh" in result) {
+          const info: Auth.Info = {
+            type: "oauth",
+            access: result.access,
+            refresh: result.refresh,
+            expires: result.expires,
+          }
+          if (result.accountId) {
+            info.accountId = result.accountId
+          }
+          await Auth.set(input.providerID, info)
+        }
+        return
+      }
+
+      throw new OauthCallbackFailed({})
+    },
+  )
+
+  export const api = fn(
+    z.object({
+      providerID: z.string(),
+      key: z.string(),
+    }),
+    async (input) => {
+      await Auth.set(input.providerID, {
+        type: "api",
+        key: input.key,
+      })
+    },
+  )
+
+  export const OauthMissing = NamedError.create(
+    "ProviderAuthOauthMissing",
+    z.object({
+      providerID: z.string(),
+    }),
+  )
+  export const OauthCodeMissing = NamedError.create(
+    "ProviderAuthOauthCodeMissing",
+    z.object({
+      providerID: z.string(),
+    }),
+  )
+
+  export const OauthCallbackFailed = NamedError.create("ProviderAuthOauthCallbackFailed", z.object({}))
+}

package/src/provider/models-macro.ts

@@ -0,0 +1,22 @@
+import { Global } from "../global"
+
+export async function data() {
+  const disable = Bun.env.NIKCLI_DISABLE_MODELS_FETCH
+  if (disable === "1" || disable === "true") {
+    return "{}"
+  }
+  const path = Bun.env.MODELS_DEV_API_JSON
+  if (path) {
+    const file = Bun.file(path)
+    if (await file.exists()) {
+      return await file.text()
+    }
+  }
+  const url = Global.Path.modelsDevUrl
+  try {
+    const json = await fetch(`${url}/api.json`).then((x) => x.text())
+    return json
+  } catch {
+    return "{}"
+  }
+}

package/src/provider/models.ts

@@ -0,0 +1,216 @@
+import { Global } from "../global"
+import { Log } from "../util/log"
+import path from "path"
+import z from "zod"
+import { data } from "./models-macro" with { type: "macro" }
+import { Installation } from "../installation"
+import { Flag } from "../flag/flag"
+
+export namespace ModelsDev {
+  const log = Log.create({ service: "models.dev" })
+  const filepath = path.join(Global.Path.cache, "models.json")
+
+  function ensureModel(database: Record<string, Provider>, providerID: string, modelID: string, model: Model) {
+    const provider = database[providerID]
+    if (!provider) return
+    if (!provider.models) return
+    if (provider.models[modelID]) return
+    provider.models[modelID] = model
+  }
+
+  function patch(database: Record<string, Provider>): Record<string, Provider> {
+    // MiniMax M2.5 (models.dev PR #875)
+    const releaseDate = "2026-02-12"
+    const limit = {
+      context: 204_800,
+      output: 131_072,
+    }
+    const modalities: NonNullable<Model["modalities"]> = {
+      input: ["text"],
+      output: ["text"],
+    }
+
+    const minimaxM25Paid: Model = {
+      id: "MiniMax-M2.5",
+      name: "MiniMax-M2.5",
+      family: "minimax",
+      release_date: releaseDate,
+      attachment: false,
+      reasoning: true,
+      tool_call: true,
+      temperature: true,
+      cost: {
+        input: 0.3,
+        output: 1.2,
+        cache_read: 0.03,
+        cache_write: 0.375,
+      },
+      limit,
+      modalities,
+      options: {},
+    }
+
+    const minimaxM25Free: Model = {
+      id: "MiniMax-M2.5",
+      name: "MiniMax-M2.5",
+      family: "minimax",
+      release_date: releaseDate,
+      attachment: false,
+      reasoning: true,
+      tool_call: true,
+      temperature: true,
+      cost: {
+        input: 0,
+        output: 0,
+        cache_read: 0,
+        cache_write: 0,
+      },
+      limit,
+      modalities,
+      options: {},
+    }
+
+    const openrouterM25: Model = {
+      id: "minimax/minimax-m2.5",
+      name: "MiniMax M2.5",
+      family: "minimax",
+      release_date: releaseDate,
+      attachment: false,
+      reasoning: true,
+      tool_call: true,
+      temperature: true,
+      interleaved: {
+        field: "reasoning_details",
+      },
+      cost: {
+        input: 0.3,
+        output: 1.2,
+      },
+      limit,
+      modalities,
+      options: {},
+    }
+
+    ensureModel(database, "minimax", "MiniMax-M2.5", minimaxM25Paid)
+    ensureModel(database, "minimax-cn", "MiniMax-M2.5", minimaxM25Paid)
+    ensureModel(database, "minimax-coding-plan", "MiniMax-M2.5", minimaxM25Free)
+    ensureModel(database, "minimax-cn-coding-plan", "MiniMax-M2.5", minimaxM25Free)
+    ensureModel(database, "openrouter", "minimax/minimax-m2.5", openrouterM25)
+
+    return database
+  }
+
+  export const Model = z.object({
+    id: z.string(),
+    name: z.string(),
+    family: z.string().optional(),
+    release_date: z.string(),
+    attachment: z.boolean(),
+    reasoning: z.boolean(),
+    temperature: z.boolean(),
+    tool_call: z.boolean(),
+    interleaved: z
+      .union([
+        z.literal(true),
+        z
+          .object({
+            field: z.enum(["reasoning_content", "reasoning_details"]),
+          })
+          .strict(),
+      ])
+      .optional(),
+    cost: z
+      .object({
+        input: z.number(),
+        output: z.number(),
+        cache_read: z.number().optional(),
+        cache_write: z.number().optional(),
+        context_over_200k: z
+          .object({
+            input: z.number(),
+            output: z.number(),
+            cache_read: z.number().optional(),
+            cache_write: z.number().optional(),
+          })
+          .optional(),
+      })
+      .optional(),
+    limit: z.object({
+      context: z.number(),
+      input: z.number().optional(),
+      output: z.number(),
+    }),
+    modalities: z
+      .object({
+        input: z.array(z.enum(["text", "audio", "image", "video", "pdf"])),
+        output: z.array(z.enum(["text", "audio", "image", "video", "pdf"])),
+      })
+      .optional(),
+    experimental: z.boolean().optional(),
+    status: z.enum(["alpha", "beta", "deprecated"]).optional(),
+    options: z.record(z.string(), z.any()),
+    headers: z.record(z.string(), z.string()).optional(),
+    provider: z.object({ npm: z.string(), api: z.string() }).optional(),
+    variants: z.record(z.string(), z.record(z.string(), z.any())).optional(),
+  })
+  export type Model = z.infer<typeof Model>
+
+  export const Provider = z.object({
+    api: z.string().optional(),
+    name: z.string(),
+    env: z.array(z.string()),
+    id: z.string(),
+    npm: z.string().optional(),
+    models: z.record(z.string(), Model),
+  })
+
+  export type Provider = z.infer<typeof Provider>
+
+  export async function get() {
+    if (!Flag.NIKCLI_DISABLE_MODELS_FETCH) {
+      refresh()
+    }
+    const file = Bun.file(filepath)
+    const result = await file.json().catch(() => {})
+    if (result) return patch(result as Record<string, Provider>)
+    if (typeof data === "function" && !Flag.NIKCLI_DISABLE_MODELS_FETCH) {
+      try {
+        const json = await data()
+        return patch(JSON.parse(json) as Record<string, Provider>)
+      } catch (error) {
+        log.error("Failed to load embedded models data", { error })
+      }
+    }
+    if (Flag.NIKCLI_DISABLE_MODELS_FETCH) return {}
+    const url = Global.Path.modelsDevUrl
+    const json = await fetch(`${url}/api.json`)
+      .then((x) => x.text())
+      .catch((error) => {
+        log.error("Failed to fetch models.dev", { error })
+        return "{}"
+      })
+    return patch(JSON.parse(json) as Record<string, Provider>)
+  }
+
+  export async function refresh() {
+    if (Flag.NIKCLI_DISABLE_MODELS_FETCH) return
+    const file = Bun.file(filepath)
+    log.info("refreshing", {
+      file,
+    })
+    const url = Global.Path.modelsDevUrl
+    const result = await fetch(`${url}/api.json`, {
+      headers: {
+        "User-Agent": Installation.USER_AGENT,
+      },
+      signal: AbortSignal.timeout(10 * 1000),
+    }).catch((e) => {
+      log.error("Failed to fetch models.dev", {
+        error: e,
+      })
+    })
+    if (result && result.ok) await Bun.write(file, await result.text())
+  }
+}
+
+setInterval(() => ModelsDev.refresh(), 60 * 1000 * 60).unref()