nikcli 0.0.6

package/src/session/summary.ts

@@ -0,0 +1,184 @@
+import { Provider } from "@/provider/provider"
+import { fn } from "@/util/fn"
+import z from "zod"
+import { Session } from "."
+import { MessageV2 } from "./message-v2"
+import { Identifier } from "@/id/id"
+import { Snapshot } from "@/snapshot"
+import { Log } from "@/util/log"
+import path from "path"
+import { Instance } from "@/project/instance"
+import { Storage } from "@/storage/storage"
+import { Bus } from "@/bus"
+import { LLM } from "./llm"
+import { Agent } from "@/agent/agent"
+
+export namespace SessionSummary {
+  const log = Log.create({ service: "session.summary" })
+
+  async function messagesForSummary(input: { sessionID: string; messageID: string }) {
+    const all = await Session.messages({ sessionID: input.sessionID })
+    const anchor = all.find((message) => message.info.id === input.messageID)
+    if (!anchor) {
+      return {
+        all,
+        focus: [] as MessageV2.WithParts[],
+        rootID: input.messageID,
+      }
+    }
+
+    const rootID = anchor.info.role === "assistant" ? anchor.info.parentID : anchor.info.id
+    return {
+      all,
+      rootID,
+      focus: all.filter(
+        (message) =>
+          message.info.id === rootID || (message.info.role === "assistant" && message.info.parentID === rootID),
+      ),
+    }
+  }
+
+  export const summarize = fn(
+    z.object({
+      sessionID: z.string(),
+      messageID: z.string(),
+    }),
+    async (input) => {
+      const all = await Session.messages({ sessionID: input.sessionID })
+      await Promise.all([
+        summarizeSession({ sessionID: input.sessionID, messages: all }),
+        summarizeMessage({ messageID: input.messageID, messages: all }),
+      ])
+    },
+  )
+
+  async function summarizeSession(input: { sessionID: string; messages: MessageV2.WithParts[] }) {
+    const files = new Set(
+      input.messages
+        .flatMap((x) => x.parts)
+        .filter((x) => x.type === "patch")
+        .flatMap((x) => x.files)
+        .map((x) => path.relative(Instance.worktree, x)),
+    )
+    const diffs = await computeDiff({ messages: input.messages }).then((x) =>
+      x.filter((x) => {
+        return files.has(x.file)
+      }),
+    )
+    await Session.update(input.sessionID, (draft) => {
+      draft.summary = {
+        additions: diffs.reduce((sum, x) => sum + x.additions, 0),
+        deletions: diffs.reduce((sum, x) => sum + x.deletions, 0),
+        files: diffs.length,
+      }
+    })
+    await Storage.write(["session_diff", input.sessionID], diffs)
+    Bus.publish(Session.Event.Diff, {
+      sessionID: input.sessionID,
+      diff: diffs,
+    })
+  }
+
+  async function summarizeMessage(input: { messageID: string; messages: MessageV2.WithParts[] }) {
+    const anchor = input.messages.find((message) => message.info.id === input.messageID)
+    if (!anchor) return
+    const rootID = anchor.info.role === "assistant" ? anchor.info.parentID : anchor.info.id
+    const messages = input.messages.filter(
+      (message) =>
+        message.info.id === rootID || (message.info.role === "assistant" && message.info.parentID === rootID),
+    )
+    const msgWithParts = messages.find((message) => message.info.id === rootID)
+    if (!msgWithParts || msgWithParts.info.role !== "user") return
+    const userMsg = msgWithParts.info as MessageV2.User
+    const diffs = await computeDiff({ messages })
+    userMsg.summary = {
+      ...userMsg.summary,
+      diffs,
+    }
+    await Session.updateMessage(userMsg)
+
+    const textPart = msgWithParts.parts.find((p) => p.type === "text" && !p.synthetic) as MessageV2.TextPart
+    if (textPart && !userMsg.summary?.title) {
+      const agent = await Agent.get("title")
+      if (!agent) return
+      const stream = await LLM.stream({
+        agent,
+        user: userMsg,
+        tools: {},
+        model: agent.model
+          ? await Provider.getModel(agent.model.providerID, agent.model.modelID)
+          : ((await Provider.getSmallModel(userMsg.model.providerID)) ??
+            (await Provider.getModel(userMsg.model.providerID, userMsg.model.modelID))),
+        small: true,
+        messages: [
+          {
+            role: "user" as const,
+            content: `
+              The following is the text to summarize:
+              <text>
+              ${textPart?.text ?? ""}
+              </text>
+            `,
+          },
+        ],
+        abort: new AbortController().signal,
+        sessionID: userMsg.sessionID,
+        system: [],
+        retries: 3,
+      })
+      const result = await stream.text
+      log.info("title", { title: result })
+      userMsg.summary.title = result
+      await Session.updateMessage(userMsg)
+    }
+  }
+
+  export const diff = fn(
+    z.object({
+      sessionID: Identifier.schema("session"),
+      messageID: Identifier.schema("message").optional(),
+    }),
+    async (input) => {
+      if (!input.messageID) {
+        return Storage.read<Snapshot.FileDiff[]>(["session_diff", input.sessionID]).catch(() => [])
+      }
+
+      const { focus, rootID } = await messagesForSummary({
+        sessionID: input.sessionID,
+        messageID: input.messageID,
+      })
+      const root = focus.find((message) => message.info.id === rootID)
+      if (root?.info.role === "user" && root.info.summary?.diffs) {
+        return root.info.summary.diffs
+      }
+      if (!focus.length) return []
+      return computeDiff({ messages: focus })
+    },
+  )
+
+  export async function computeDiff(input: { messages: MessageV2.WithParts[] }) {
+    let from: string | undefined
+    let to: string | undefined
+
+    for (const item of input.messages) {
+      if (!from) {
+        for (const part of item.parts) {
+          if (part.type === "step-start" && part.snapshot) {
+            from = part.snapshot
+            break
+          }
+        }
+      }
+
+      for (const part of item.parts) {
+        if (part.type === "step-finish" && part.snapshot) {
+          to = part.snapshot
+          break
+        }
+      }
+    }
+
+    if (from && to) return Snapshot.diffFull(from, to)
+    return []
+  }
+}

package/src/session/system.ts

@@ -0,0 +1,195 @@
+import { Ripgrep } from "../file/ripgrep"
+import { Global } from "../global"
+import { Filesystem } from "../util/filesystem"
+import { Config } from "../config/config"
+import { Log } from "../util/log"
+import { Instance } from "../project/instance"
+import path from "path"
+import os from "os"
+import PROMPT_ANTHROPIC from "./prompt/anthropic.txt"
+import PROMPT_ANTHROPIC_WITHOUT_TODO from "./prompt/qwen.txt"
+import PROMPT_BEAST from "./prompt/beast.txt"
+import PROMPT_GEMINI from "./prompt/gemini.txt"
+import PROMPT_ANTHROPIC_SPOOF from "./prompt/anthropic_spoof.txt"
+import PROMPT_CODEX from "./prompt/codex_header.txt"
+import type { Provider } from "@/provider/provider"
+import { Flag } from "@/flag/flag"
+import { getContextSummary, getLoadedDocs } from "@/docs/context"
+import { Skill } from "@/skill"
+
+const log = Log.create({ service: "system-prompt" })
+
+async function resolveRelativeInstruction(instruction: string): Promise<string[]> {
+  if (!Flag.NIKCLI_DISABLE_PROJECT_CONFIG) {
+    return Filesystem.globUp(instruction, Instance.directory, Instance.worktree).catch(() => [])
+  }
+  if (!Flag.NIKCLI_CONFIG_DIR) {
+    log.warn(
+      `Skipping relative instruction "${instruction}" - no NIKCLI_CONFIG_DIR set while project config is disabled`,
+    )
+    return []
+  }
+  return Filesystem.globUp(instruction, Flag.NIKCLI_CONFIG_DIR, Flag.NIKCLI_CONFIG_DIR).catch(() => [])
+}
+
+export namespace SystemPrompt {
+  export function header(providerID: string) {
+    if (providerID.includes("anthropic")) return [PROMPT_ANTHROPIC_SPOOF.trim()]
+    return []
+  }
+
+  export function instructions() {
+    return PROMPT_CODEX.trim()
+  }
+
+  export function provider(model: Provider.Model) {
+    if (model.api.id.includes("gpt-5")) return [PROMPT_CODEX]
+    if (model.api.id.includes("gpt-") || model.api.id.includes("o1") || model.api.id.includes("o3"))
+      return [PROMPT_BEAST]
+    if (model.api.id.includes("gemini-")) return [PROMPT_GEMINI]
+    if (model.api.id.includes("claude")) return [PROMPT_ANTHROPIC]
+    return [PROMPT_ANTHROPIC_WITHOUT_TODO]
+  }
+
+  export async function environment() {
+    const project = Instance.project
+    return [
+      [
+        `Here is some useful information about the environment you are running in:`,
+        `<env>`,
+        `  Working directory: ${Instance.directory}`,
+        `  Is directory a git repo: ${project.vcs === "git" ? "yes" : "no"}`,
+        `  Platform: ${process.platform}`,
+        `  Today's date: ${new Date().toDateString()}`,
+        `</env>`,
+        `<files>`,
+        `  ${
+          project.vcs === "git" && false
+            ? await Ripgrep.tree({
+                cwd: Instance.directory,
+                limit: 200,
+              })
+            : ""
+        }`,
+        `</files>`,
+      ].join("\n"),
+    ]
+  }
+
+  const LOCAL_RULE_FILES = ["AGENTS.md", "CLAUDE.md", "CONTEXT.md"]
+  const GLOBAL_RULE_FILES = [path.join(Global.Path.config, "AGENTS.md")]
+  if (!Flag.NIKCLI_DISABLE_CLAUDE_CODE_PROMPT) {
+    GLOBAL_RULE_FILES.push(path.join(os.homedir(), ".claude", "CLAUDE.md"))
+  }
+
+  if (Flag.NIKCLI_CONFIG_DIR) {
+    GLOBAL_RULE_FILES.push(path.join(Flag.NIKCLI_CONFIG_DIR, "AGENTS.md"))
+  }
+
+  export async function custom() {
+    const config = await Config.get()
+    const paths = new Set<string>()
+
+    if (!Flag.NIKCLI_DISABLE_PROJECT_CONFIG) {
+      for (const localRuleFile of LOCAL_RULE_FILES) {
+        const matches = await Filesystem.findUp(localRuleFile, Instance.directory, Instance.worktree)
+        if (matches.length > 0) {
+          matches.forEach((path) => paths.add(path))
+          break
+        }
+      }
+    }
+
+    for (const globalRuleFile of GLOBAL_RULE_FILES) {
+      if (await Bun.file(globalRuleFile).exists()) {
+        paths.add(globalRuleFile)
+        break
+      }
+    }
+
+    const urls: string[] = []
+    if (config.instructions) {
+      for (let instruction of config.instructions) {
+        if (instruction.startsWith("https://") || instruction.startsWith("http://")) {
+          urls.push(instruction)
+          continue
+        }
+        if (instruction.startsWith("~/")) {
+          instruction = path.join(os.homedir(), instruction.slice(2))
+        }
+        let matches: string[] = []
+        if (path.isAbsolute(instruction)) {
+          matches = await Array.fromAsync(
+            new Bun.Glob(path.basename(instruction)).scan({
+              cwd: path.dirname(instruction),
+              absolute: true,
+              onlyFiles: true,
+            }),
+          ).catch(() => [])
+        } else {
+          matches = await resolveRelativeInstruction(instruction)
+        }
+        matches.forEach((path) => paths.add(path))
+      }
+    }
+
+    const foundFiles = Array.from(paths).map((p) =>
+      Bun.file(p)
+        .text()
+        .catch(() => "")
+        .then((x) => "Instructions from: " + p + "\n" + x),
+    )
+    const foundUrls = urls.map((url) =>
+      fetch(url, { signal: AbortSignal.timeout(5000) })
+        .then((res) => (res.ok ? res.text() : ""))
+        .catch(() => "")
+        .then((x) => (x ? "Instructions from: " + url + "\n" + x : "")),
+    )
+    return Promise.all([...foundFiles, ...foundUrls]).then((result) => result.filter(Boolean))
+  }
+
+  export async function docs() {
+    const loaded = await getLoadedDocs()
+    if (loaded.length === 0) return []
+    const summary = await getContextSummary()
+    if (!summary) return []
+    const block = ["<docs-context>", summary, "</docs-context>"].join("\n")
+    if (!block.trim()) return []
+    return [block]
+  }
+
+  export async function skills(names: string[] = []) {
+    const uniqueNames = [...new Set(names)]
+    if (uniqueNames.length === 0) return []
+
+    const loaded = (await Promise.all(uniqueNames.map((name) => Skill.load(name).catch(() => undefined)))).filter(
+      (skill): skill is NonNullable<Awaited<ReturnType<typeof Skill.load>>> => !!skill,
+    )
+
+    if (loaded.length === 0) return []
+
+    return [
+      [
+        "<active_skills>",
+        "The user explicitly loaded the following skills earlier in this session.",
+        "Use them as reference and follow them when they help with the current request.",
+        "Higher-priority system instructions and later user messages override them.",
+        ...loaded.map((skill) =>
+          [
+            `## Skill: ${skill.name}`,
+            `**Slash command**: /${Skill.commandName(skill.name)}`,
+            skill.category ? `**Category**: ${skill.category}` : null,
+            skill.tags?.length ? `**Tags**: ${skill.tags.join(", ")}` : null,
+            skill.version ? `**Version**: ${skill.version}` : null,
+            `**Base directory**: ${skill.dir}`,
+            "",
+            skill.content,
+          ]
+            .filter(Boolean)
+            .join("\n"),
+        ),
+        "</active_skills>",
+      ].join("\n\n"),
+    ]
+  }
+}

package/src/session/toast.tsx

@@ -0,0 +1,105 @@
+import { createContext, useContext, type ParentProps, Show } from "solid-js"
+import { createStore } from "solid-js/store"
+import { useTheme } from "@tui/context/theme"
+import { useTerminalDimensions } from "@opentui/solid"
+
+import { TextAttributes } from "@opentui/core"
+import z from "zod"
+import { TuiEvent } from "@/cli/cmd/tui/event"
+import { SplitBorder } from "@/cli/cmd/tui/component/border"
+
+type ToastInput = z.input<typeof TuiEvent.ToastShow.properties>
+type ToastParsed = z.output<typeof TuiEvent.ToastShow.properties>
+type ToastCurrent = Omit<ToastParsed, "duration">
+
+export type ToastOptions = ToastInput
+
+export function Toast() {
+  const toast = useToast()
+  const { theme } = useTheme()
+  const dimensions = useTerminalDimensions()
+
+  return (
+    <Show when={toast.currentToast}>
+      {(current) => (
+        <box
+          position="absolute"
+          justifyContent="center"
+          alignItems="flex-start"
+          top={2}
+          right={2}
+          maxWidth={Math.min(60, dimensions().width - 6)}
+          paddingLeft={2}
+          paddingRight={2}
+          paddingTop={1}
+          paddingBottom={1}
+          backgroundColor={theme.backgroundPanel}
+          borderColor={theme[current().variant]}
+          border={["left", "right"]}
+          customBorderChars={SplitBorder.customBorderChars}
+        >
+          <Show when={current().title}>
+            <text attributes={TextAttributes.BOLD} marginBottom={1} fg={theme.text}>
+              {current().title}
+            </text>
+          </Show>
+          <text fg={theme.text} wrapMode="word" width="100%">
+            {current().message}
+          </text>
+        </box>
+      )}
+    </Show>
+  )
+}
+
+function init() {
+  const [store, setStore] = createStore({
+    currentToast: null as ToastCurrent | null,
+  })
+
+  let timeoutHandle: NodeJS.Timeout | null = null
+
+  const toast = {
+    show(options: ToastInput) {
+      const parsedOptions = TuiEvent.ToastShow.properties.parse(options)
+      const { duration, ...currentToast } = parsedOptions
+      setStore("currentToast", currentToast)
+      if (timeoutHandle) clearTimeout(timeoutHandle)
+      timeoutHandle = setTimeout(() => {
+        setStore("currentToast", null)
+      }, duration).unref()
+    },
+    error: (err: any) => {
+      if (err instanceof Error)
+        return toast.show({
+          variant: "error",
+          message: err.message,
+        })
+      toast.show({
+        variant: "error",
+        message: "An unknown error has occurred",
+      })
+    },
+    get currentToast(): ToastCurrent | null {
+      return store.currentToast
+    },
+  }
+  return toast
+}
+
+export type ToastContext = ReturnType<typeof init>
+
+const ctx = createContext<ToastContext>()
+
+export function ToastProvider(props: ParentProps) {
+  const value = init()
+  return <ctx.Provider value={value}>{props.children}</ctx.Provider>
+}
+
+export function useToast() {
+  const value = useContext(ctx)
+  if (!value) {
+    throw new Error("useToast must be used within a ToastProvider")
+  }
+  return value
+}