@lef237/hagumi 0.0.0-stage → 0.1.0

package/src/config.ts

@@ -0,0 +1,96 @@
+// The user's settings, in ~/.hagumi/config.json. The file is written with the defaults on first use,
+// so that the settings can be read, and changed, in one place. Anything left out takes its default;
+// `hagumi config` shows every value in effect. The file is never rewritten behind the user's back.
+import { paths } from "./app"
+import { type FaceSetName, faceSets } from "./faces"
+import { Problem, resolveLanguage, type Spoken } from "./i18n"
+import type { CommandRules } from "./policy"
+import { readJson, writeJson } from "./store"
+
+export const languages = ["auto", "ja", "en"] as const
+export type Language = (typeof languages)[number]
+
+export type Config = {
+  // What the partner is called, in each language: a name in another script would look like a mistake.
+  name: Record<Spoken, string>
+  // "auto" follows the system's locale.
+  language: Language
+  faces: FaceSetName
+  // The model a chat starts with, named <provider>/<model>.
+  model: string
+  // Where hagumi new makes a place for each chat; ~ is the home directory.
+  workspaces: string
+  commands: CommandRules
+}
+
+export function defaultConfig(): Config {
+  return {
+    name: { ja: "はぐみ", en: "Hagumi" },
+    language: "auto",
+    faces: "kaomoji",
+    model: "chatgpt/gpt-6-luna",
+    workspaces: "~/hagumi-work",
+    commands: {
+      // Commands that only look around.
+      allow: ["ls", "pwd", "cd", "echo", "cat", "head", "tail", "wc", "grep", "rg", "git status", "git diff", "git log", "git show"],
+      deny: ["sudo"],
+    },
+  }
+}
+
+// The partner's name in the language it speaks now.
+export function nameOf(config: Config): string {
+  return config.name[resolveLanguage(config.language)]
+}
+
+export async function loadConfig(path = paths.config): Promise<Config> {
+  let saved: unknown
+  try {
+    saved = await readJson(path)
+  } catch (error) {
+    throw new Problem("badConfig", `${path}: ${error instanceof Error ? error.message : error}`)
+  }
+  const defaults = defaultConfig()
+  if (saved === undefined) {
+    await writeJson(path, defaults)
+    return defaults
+  }
+
+  const fields = (saved ?? {}) as Record<string, unknown>
+  const commands = (fields.commands ?? {}) as Record<string, unknown>
+  const wrong = (key: string, expected: string) => new Problem("badConfig", `${path}: ${key} must be ${expected}`)
+  const filled = (value: unknown) => typeof value === "string" && value.trim() !== ""
+  const oneOf = <T extends string>(key: string, allowed: readonly T[], fallback: T): T => {
+    const value = fields[key] ?? fallback
+    if (allowed.includes(value as T)) return value as T
+    throw wrong(key, `one of ${allowed.join(", ")}`)
+  }
+  const text = (key: string, fallback: string): string => {
+    const value = fields[key] ?? fallback
+    if (filled(value)) return value as string
+    throw wrong(key, "a non-empty string")
+  }
+  // One name for every language, or names by language; a language left out keeps its default name.
+  const names = (): Record<Spoken, string> => {
+    const value = fields.name ?? {}
+    if (filled(value)) return { ja: value as string, en: value as string }
+    const byLanguage = Object.entries(value as object)
+    if (typeof value === "object" && byLanguage.every(([language, name]) => language in defaults.name && filled(name))) {
+      return { ...defaults.name, ...(value as Partial<Record<Spoken, string>>) }
+    }
+    throw wrong("name", 'a name, or names by language such as { "ja": "はぐみ", "en": "Hagumi" }')
+  }
+  const list = (key: "allow" | "deny"): string[] => {
+    const value = commands[key] ?? []
+    if (Array.isArray(value) && value.every((rule) => typeof rule === "string")) return value
+    throw wrong(`commands.${key}`, "a list of strings")
+  }
+  return {
+    name: names(),
+    language: oneOf("language", languages, defaults.language),
+    faces: oneOf("faces", Object.keys(faceSets) as FaceSetName[], defaults.faces),
+    model: text("model", defaults.model),
+    workspaces: text("workspaces", defaults.workspaces),
+    commands: { allow: list("allow"), deny: list("deny") },
+  }
+}

package/src/conversation.ts

@@ -0,0 +1,88 @@
+// hagumi's own view of a conversation. The session log is the source of truth:
+// every request is rendered from it, so what the model sees can always be read back.
+import { userAgent } from "./app"
+import { compact } from "./compact"
+import { Problem } from "./i18n"
+import type { LogEntry, SessionLog } from "./log"
+import { credential, type ModelChoice } from "./providers"
+import { runTool, type Tool, type ToolContext, tools } from "./tools"
+import { streamEvents } from "./wire/stream"
+
+// `arguments` is the JSON text the model produced, kept as it was.
+export type ToolCall = { id: string; name: string; arguments: string }
+
+export type Message =
+  | { role: "user"; text: string }
+  | { role: "assistant"; text: string; toolCalls: ToolCall[] }
+  | { role: "tool"; callId: string; output: string }
+
+// What a turn reports while it runs; the screen decides how to show it.
+export type TurnEvent =
+  | { kind: "thinking" }
+  | { kind: "text"; delta: string }
+  | { kind: "tool_call"; call: ToolCall }
+  | { kind: "tool_result"; call: ToolCall; ok: boolean }
+  // Old tool outputs were left out of the conversation as this turn began.
+  | { kind: "compacted"; outputs: number }
+
+// Enough for real work; stops a model that keeps calling tools from draining the plan.
+const maxSteps = 30
+
+export function messagesFrom(entries: LogEntry[]): Message[] {
+  return entries.flatMap((entry): Message[] => {
+    switch (entry.kind) {
+      case "user":
+        return [{ role: "user", text: String(entry.text) }]
+      case "assistant":
+        return [{ role: "assistant", text: String(entry.text), toolCalls: (entry.toolCalls as ToolCall[]) ?? [] }]
+      case "tool_result":
+        return [{ role: "tool", callId: String(entry.callId), output: String(entry.output) }]
+      default:
+        return []
+    }
+  })
+}
+
+// One exchange: the user speaks, then the model replies, calling tools until it has an answer.
+export async function* turn(options: {
+  log: SessionLog
+  choice: ModelChoice
+  text: string
+  system: string
+  context: ToolContext
+  // The tools the model may call: every one, unless the turn needs none, as a search does.
+  tools?: Tool[]
+}): AsyncGenerator<TurnEvent> {
+  const { log, choice, text, system, context, tools: offered = tools } = options
+  const { provider, wire } = choice
+  const key = await credential(provider)
+  await log.append({ kind: "user", text })
+
+  const headers = {
+    "Content-Type": "application/json",
+    "User-Agent": userAgent,
+    [provider.sessionHeader]: log.id,
+    ...wire.auth(key),
+  }
+  for (let step = 0; step < maxSteps; step++) {
+    const { conversation, omitted } = compact(messagesFrom(await log.read()))
+    // What was left out can no longer be seen, so every file must be read again before it is changed.
+    if (step === 0 && omitted > 0) {
+      context.seen.clear()
+      yield { kind: "compacted", outputs: omitted }
+    }
+    yield { kind: "thinking" }
+    const body = wire.request({ model: choice.model, system, conversation, tools: offered })
+    const reply = yield* wire.read(streamEvents({ url: provider.baseUrl + wire.path, headers, body, log }))
+    await log.append({ kind: "assistant", text: reply.text, toolCalls: reply.toolCalls, model: choice.ref })
+    if (reply.toolCalls.length === 0) return
+
+    for (const call of reply.toolCalls) {
+      yield { kind: "tool_call", call }
+      const result = await runTool(call, context)
+      await log.append({ kind: "tool_result", callId: call.id, name: call.name, ...result })
+      yield { kind: "tool_result", call, ok: result.ok }
+    }
+  }
+  throw new Problem("tooManySteps", String(maxSteps))
+}

package/src/diff.ts

@@ -0,0 +1,31 @@
+export type DiffLine = { mark: " " | "-" | "+"; text: string }
+
+// The changed region of two texts as a single hunk: lines shared at both ends are trimmed,
+// keeping a little context. Enough to show one change for approval; `before` is undefined for a new file.
+export function hunk(before: string | undefined, after: string, context = 2): DiffLine[] {
+  const added = (text: string): DiffLine => ({ mark: "+", text })
+  if (before === undefined) return lines(after).map(added)
+
+  const a = lines(before)
+  const b = lines(after)
+  let start = 0
+  while (start < a.length && start < b.length && a[start] === b[start]) start++
+  let endA = a.length
+  let endB = b.length
+  while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) {
+    endA--
+    endB--
+  }
+  const kept = (text: string): DiffLine => ({ mark: " ", text })
+  return [
+    ...a.slice(Math.max(0, start - context), start).map(kept),
+    ...a.slice(start, endA).map((text): DiffLine => ({ mark: "-", text })),
+    ...b.slice(start, endB).map(added),
+    ...a.slice(endA, endA + context).map(kept),
+  ]
+}
+
+// A final newline ends the last line rather than starting an empty one.
+function lines(text: string): string[] {
+  return text.replace(/\n$/, "").split("\n")
+}

package/src/faces.ts

@@ -0,0 +1,34 @@
+// hagumi's face in each moment. Which set to wear is a setting of its own, apart from the language.
+export type Mood = "greeting" | "thinking" | "working" | "waiting" | "troubled" | "replying" | "happy"
+
+export type FaceSet = Record<Mood, string>
+
+export const faceSets = {
+  kaomoji: {
+    greeting: "(・ω・)ﾉ",
+    thinking: "(・_・)…",
+    working: "(｀・ω・´)",
+    waiting: "(・ω・)?",
+    troubled: "(´・ω・`)",
+    replying: "(・ω・)",
+    happy: "(＾▽＾)",
+  },
+  emoji: { greeting: "👋", thinking: "🤔", working: "🔧", waiting: "🙋", troubled: "😣", replying: "💬", happy: "😊" },
+  ascii: {
+    greeting: "(^_^)/",
+    thinking: "(o_o)...",
+    working: "(>_<)",
+    waiting: "(?_?)",
+    troubled: "(;_;)",
+    replying: "(^_^)",
+    happy: "(^o^)",
+  },
+  none: { greeting: "", thinking: "...", working: "", waiting: "", troubled: "", replying: "", happy: "" },
+} satisfies Record<string, FaceSet>
+
+export type FaceSetName = keyof typeof faceSets
+
+// A face before some text, or just the text when the face is empty.
+export function withFace(face: string, text: string): string {
+  return face ? `${face} ${text}` : text
+}

package/src/i18n.ts

@@ -0,0 +1,312 @@
+// Every fixed piece of text the screen shows, in each language. The core never builds such text;
+// what the partner says freely comes from the model, in the language the settings ask for.
+
+// Problems the user can act on; anything else is reported as-is.
+export type ProblemKey =
+  | "usage"
+  | "notSignedIn"
+  | "noTokenSharing"
+  | "sessionNotFound"
+  | "unknownModel"
+  | "unknownProvider"
+  | "tooManySteps"
+  | "badConfig"
+  | "unknownLanguage"
+  | "cancelled"
+
+type Messages = {
+  problem: Record<ProblemKey, (detail: string) => string>
+  openUrl: (url: string) => string
+  askApiKey: (provider: string) => string
+  signedIn: (provider: string) => string
+  callbackPage: string
+  greeting: (name: string, hour: number) => string
+  welcomeBack: (name: string) => string
+  chatInfo: (workspace: string, model: string, logPath: string) => string
+  // hagumi new shows the place it made on a line of its own, easy to copy into another tab, and the way there
+  // again as it ends: a program cannot move its shell.
+  madeWorkspace: (workspace: string) => string
+  goThere: (workspace: string) => string
+  tidyEmpty: string
+  tidied: string
+  pruneNone: string
+  pruneFound: (places: string[]) => string
+  pruneAsk: string
+  boardColumns: Record<"doing" | "todo" | "done", string>
+  boardEmpty: string
+  // The list hagumi starts with, and finding older projects in it.
+  whereToStart: string
+  searchHint: string
+  searching: string
+  searchNone: string
+  whichOne: string
+  boardMade: string
+  startNew: string
+  startHere: (workspace: string) => string
+  boardNow: (item: string) => string
+  boardNext: (item: string) => string
+  pruned: (count: number) => string
+  chatHelp: string
+  model: (model: string) => string
+  language: (name: string) => string
+  changeHeader: (tool: string, path: string, isNew: boolean) => string
+  moreLines: (count: number) => string
+  commandHeader: (command: string) => string
+  approve: string
+  approvedForSession: string
+  compacted: (outputs: number) => string
+  // Asked after a reply, for each fact the partner proposed to remember.
+  rememberThis: (fact: string) => string
+  rememberSelf: (fact: string) => string
+  // Said instead of asking, when a fact comes from the user's own words.
+  kept: (fact: string) => string
+  keptSelf: (fact: string) => string
+  remembered: string
+  allowedByRule: (rules: string) => string
+  deniedByRule: (rule: string) => string
+  configShown: (path: string) => string
+  personaShown: (path: string, used: number, limit: number) => string
+  memoryShown: (path: string, used: number, limit: number) => string
+  // How the partner first speaks: the seed of persona.md, written on first use.
+  personaSeed: string
+  memoryEmpty: string
+  memoryChanges: string
+  memoryFull: (fact: string) => string
+  noTerminal: string
+  footer: (model: string, logPath: string) => string
+}
+
+const en: Messages = {
+  problem: {
+    usage: (providers) =>
+      [
+        "Usage:",
+        "  hagumi login [provider]",
+        "  hagumi models [provider]",
+        "  hagumi ask [--model <provider>/<model>] [--session <id>] <text>",
+        "  hagumi",
+        "  hagumi . [--model <provider>/<model>] [--session <id>]",
+        "  hagumi new [--model <provider>/<model>]",
+        "  hagumi prune",
+        "  hagumi inspect <session id>",
+        "  hagumi config",
+        "  hagumi memory",
+        `Providers: ${providers}`,
+      ].join("\n"),
+    notSignedIn: (provider) => `Not signed in to ${provider} yet. Run \`hagumi login ${provider}\` first.`,
+    noTokenSharing: () =>
+      "Sign-in finished without permission to use your ChatGPT plan. Run `hagumi login` again and allow it.",
+    sessionNotFound: () => "No such session, or nothing has been sent in it yet.",
+    unknownModel: (ref) => `Unknown model: ${ref}. Name it as <provider>/<model>, such as chatgpt/gpt-6-luna.`,
+    unknownProvider: (provider) => `Unknown provider: ${provider}`,
+    tooManySteps: (steps) => `Stopped after ${steps} steps in one turn. Ask again to let it continue.`,
+    badConfig: (detail) => `The settings file cannot be read: ${detail}`,
+    unknownLanguage: (choices) => `Choose a language from ${choices}.`,
+    cancelled: () => "Cancelled.",
+  },
+  openUrl: (url) => `Sign in with ChatGPT in your browser:\n${url}`,
+  askApiKey: (provider) => `API key for ${provider} (hidden): `,
+  signedIn: (provider) => `Signed in to ${provider}.`,
+  callbackPage: "Received. You can close this tab and return to your terminal.",
+  greeting: (name, hour) =>
+    hour < 5
+      ? `Still up? It's ${name}. Let's not stay too late.`
+      : hour < 11
+        ? `Good morning! It's ${name}. Let's have a good day.`
+        : hour < 18
+          ? `Hi, it's ${name}. Where shall we start?`
+          : `Good evening, it's ${name}. Thanks for today.`,
+  welcomeBack: (name) => `Welcome back! It's ${name}. Let's pick up where we left off.`,
+  chatInfo: (workspace, model, logPath) =>
+    `workspace: ${workspace}\nmodel: ${model}  log: ${logPath}\n/help lists the commands. Press Ctrl+D to finish.`,
+  madeWorkspace: (workspace) => `Made a new place to work. To open it in another tab, use this path:\n  ${workspace}\n`,
+  goThere: (workspace) => `To go there: cd ${workspace}`,
+  tidyEmpty: "This place is still empty. Tidy it away? [y/n] ",
+  tidied: "Tidied it away.",
+  pruneNone: "No empty places to tidy away.",
+  pruneFound: (places) => `${places.length} empty ${places.length === 1 ? "place" : "places"}:\n${places.join("\n")}`,
+  pruneAsk: "Tidy them away? [y/n] ",
+  boardColumns: { doing: "Doing", todo: "To do", done: "Done" },
+  boardEmpty: "This project's board is still empty.",
+  whereToStart: "Where shall we start? ",
+  searchHint: "For another project, type what you remember of it: a name, a day, what the work was about.",
+  searching: "Looking for it…",
+  searchNone: "Nothing matched.",
+  whichOne: "Which one? ",
+  boardMade: "I put this project on the list. Next time, pick it up from the list hagumi starts with.",
+  startNew: "Start something new",
+  startHere: (workspace) => `Start here (${workspace})`,
+  boardNow: (item) => `now: ${item}`,
+  boardNext: (item) => `next: ${item}`,
+  pruned: (count) => `Tidied away ${count}.`,
+  chatHelp: [
+    "/models [provider]          the models you can use",
+    "/model <provider>/<model>   switch models from the next message",
+    "/language [auto|ja|en]      switch languages for this chat",
+    "/board                      this project's board",
+    "/help                       this list",
+    "Ctrl+D                      finish",
+  ].join("\n"),
+  model: (model) => `model: ${model}`,
+  language: (name) => `language: ${name} (choose from auto / ja / en; for this chat only)`,
+  changeHeader: (tool, path, isNew) => `  ✎ ${tool} ${path}${isNew ? " (new file)" : ""}`,
+  moreLines: (count) => `    … ${count} more lines`,
+  commandHeader: (command) => `  $ ${command}\n    (sandboxed: writes only inside the working directory, no network)`,
+  approve: "Allow this? [y] yes / [n] no / [a] always in this session: ",
+  approvedForSession: "  (allowed for this session)",
+  compacted: (outputs) =>
+    `(The conversation grew long, so ${outputs} old tool outputs were left out. Files are read again when needed.)`,
+  rememberThis: (fact) => `Shall I remember this? "${fact}" [y/n] `,
+  rememberSelf: (fact) => `Shall I remember this about myself? "${fact}" [y/n] `,
+  kept: (fact) => `  Remembered: "${fact}" (from the next session on; hagumi memory to look it over)`,
+  keptSelf: (fact) => `  Remembered about myself: "${fact}" (from the next session on; hagumi memory to look it over)`,
+  remembered: "Remembered! I'll use it from the next session.",
+  allowedByRule: (rules) => `  (your allow list has ${rules}, so it runs without asking)`,
+  deniedByRule: (rule) => `  (your deny list has ${rule}, so it does not run)`,
+  configShown: (path) => `Settings: ${path}`,
+  personaShown: (path, used, limit) => `Persona: ${path} (${used} of ${limit} characters)`,
+  memoryShown: (path, used, limit) => `Memory: ${path} (${used} of ${limit} characters)`,
+  personaSeed: "- Speaks in a soft, casual voice, and keeps it short\n- Is openly glad when things go well\n",
+  memoryEmpty: "Nothing remembered yet.",
+  memoryChanges: "Recent changes:",
+  memoryFull: (fact) => `My memory is full, so I couldn't remember "${fact}". See \`hagumi memory\` and tidy it up.`,
+  noTerminal: "  No terminal to ask, so it was declined.",
+  footer: (model, logPath) => `model: ${model}\nlog: ${logPath}`,
+}
+
+const ja: Messages = {
+  problem: {
+    usage: (providers) =>
+      [
+        "使い方:",
+        "  hagumi login [プロバイダ]",
+        "  hagumi models [プロバイダ]",
+        "  hagumi ask [--model <プロバイダ>/<モデル>] [--session <id>] <テキスト>",
+        "  hagumi",
+        "  hagumi . [--model <プロバイダ>/<モデル>] [--session <id>]",
+        "  hagumi new [--model <プロバイダ>/<モデル>]",
+        "  hagumi prune",
+        "  hagumi inspect <セッション ID>",
+        "  hagumi config",
+        `プロバイダ: ${providers}`,
+      ].join("\n"),
+    notSignedIn: (provider) =>
+      `${provider} にはまだサインインしていません。先に \`hagumi login ${provider}\` を実行してください。`,
+    noTokenSharing: () =>
+      "ChatGPT プランの利用が許可されないままサインインが終わりました。もう一度 `hagumi login` を実行して許可してください。",
+    sessionNotFound: () => "そのセッションは見つからないか、まだ何も送っていません。",
+    unknownModel: (ref) =>
+      `知らないモデルです: ${ref}。<プロバイダ>/<モデル> の形で指定してください（例: chatgpt/gpt-6-luna）。`,
+    unknownProvider: (provider) => `知らないプロバイダです: ${provider}`,
+    tooManySteps: (steps) => `1ターンで ${steps} ステップに達したので止めました。続けるには、もう一度頼んでください。`,
+    badConfig: (detail) => `設定ファイルを読めません: ${detail}`,
+    unknownLanguage: (choices) => `言語は ${choices} から選んでください。`,
+    cancelled: () => "中止しました。",
+  },
+  openUrl: (url) => `ブラウザで ChatGPT にサインインしてください:\n${url}`,
+  askApiKey: (provider) => `${provider} の API キー（画面には表示しません）: `,
+  signedIn: (provider) => `${provider} にサインインしました。`,
+  callbackPage: "受け取りました。このタブを閉じて、ターミナルに戻ってください。",
+  greeting: (name, hour) =>
+    hour < 5
+      ? `こんばんは、${name}だよ。夜ふかしはほどほどにね。`
+      : hour < 11
+        ? `おはよう、${name}だよ。今日もよろしくね。`
+        : hour < 18
+          ? `こんにちは、${name}だよ。何から始めようか？`
+          : `こんばんは、${name}だよ。今日もおつかれさま。`,
+  welcomeBack: (name) => `おかえり、${name}だよ。続きをやろう。`,
+  chatInfo: (workspace, model, logPath) =>
+    `作業の場所: ${workspace}\nモデル: ${model}  ログ: ${logPath}\n/help でコマンドの一覧。終わるときは Ctrl+D。`,
+  madeWorkspace: (workspace) => `新しい作業の場所を作ったよ。別のタブで開くときは、このパスをどうぞ：\n  ${workspace}\n`,
+  goThere: (workspace) => `移るなら: cd ${workspace}`,
+  tidyEmpty: "この場所は空のままだけど、片付ける？ [y/n] ",
+  tidied: "片付けたよ。",
+  pruneNone: "片付ける空の作業の場所はないよ。",
+  pruneFound: (places) => `空の作業の場所が ${places.length} つあるよ：\n${places.join("\n")}`,
+  pruneAsk: "片付ける？ [y/n] ",
+  boardColumns: { doing: "やっている", todo: "やること", done: "終わった" },
+  boardEmpty: "このプロジェクトのボードは、まだ空だよ。",
+  whereToStart: "どこから始める？ ",
+  searchHint: "ほかのプロジェクトは、覚えていること（名前、日付、どんな作業だったか）を打つと探すよ。",
+  searching: "探しているよ…",
+  searchNone: "見つからなかったよ。",
+  whichOne: "どれにする？ ",
+  boardMade: "このプロジェクトを一覧に載せたよ。次から hagumi の一覧から再開できるよ。",
+  startNew: "新しく始める",
+  startHere: (workspace) => `ここで始める（${workspace}）`,
+  boardNow: (item) => `いま: ${item}`,
+  boardNext: (item) => `次: ${item}`,
+  pruned: (count) => `${count} つ片付けたよ。`,
+  chatHelp: [
+    "/models [プロバイダ]          使えるモデルの一覧",
+    "/model <プロバイダ>/<モデル>   次の発言からモデルを切り替える",
+    "/language [auto|ja|en]        このチャットの言語を切り替える",
+    "/board                        このプロジェクトのボード",
+    "/help                         この一覧",
+    "Ctrl+D                        終わる",
+  ].join("\n"),
+  model: (model) => `モデル: ${model}`,
+  language: (name) => `言語: ${name}（auto / ja / en から選べます。このチャットの間だけ有効）`,
+  changeHeader: (tool, path, isNew) => `  ✎ ${tool} ${path}${isNew ? "（新しいファイル）" : ""}`,
+  moreLines: (count) => `    …ほか ${count} 行`,
+  commandHeader: (command) => `  $ ${command}\n    （サンドボックス内: 書き込みは作業ディレクトリだけ、ネットワークなし）`,
+  approve: "許可しますか？ [y] はい / [n] いいえ / [a] このセッションでは常に許可: ",
+  approvedForSession: "  （このセッションでは許可済み）",
+  compacted: (outputs) => `（会話が大きくなったので、古いツールの出力を ${outputs} 件省きました。必要なら読み直します）`,
+  rememberThis: (fact) => `覚えていい？「${fact}」 [y/n] `,
+  rememberSelf: (fact) => `自分のことをこう覚えていい？「${fact}」 [y/n] `,
+  kept: (fact) => `  覚えたよ：「${fact}」（次のセッションから使うね。見直すなら hagumi memory）`,
+  keptSelf: (fact) => `  自分のこととして覚えたよ：「${fact}」（次のセッションから使うね。見直すなら hagumi memory）`,
+  remembered: "覚えた！ 次のセッションから使うね。",
+  allowedByRule: (rules) => `  （許可リストの ${rules} に一致するので、確認せずに実行します）`,
+  deniedByRule: (rule) => `  （禁止リストの ${rule} に一致するので、実行しません）`,
+  configShown: (path) => `設定ファイル: ${path}`,
+  personaShown: (path, used, limit) => `人格: ${path}（${used} / ${limit} 字）`,
+  memoryShown: (path, used, limit) => `記憶: ${path}（${used} / ${limit} 字）`,
+  personaSeed: "- 一人称は「ぼく」\n- やわらかい話し言葉で、短く話す\n- うまくいったときは、素直に喜ぶ\n",
+  memoryEmpty: "まだ何も覚えていません。",
+  memoryChanges: "最近の変更:",
+  memoryFull: (fact) => `記憶がいっぱいで、「${fact}」は覚えられなかった。hagumi memory で中身を見て、整理してね。`,
+  noTerminal: "  確認できる端末がないので、断りました。",
+  footer: (model, logPath) => `モデル: ${model}\nログ: ${logPath}`,
+}
+
+const messages = { en, ja }
+
+// The languages hagumi speaks.
+export type Spoken = keyof typeof messages
+
+// Each language by its own name.
+const nativeNames = { ja: "日本語", en: "English" }
+
+// A language as people would recognize it; "auto" also tells what it resolves to.
+export function languageName(language: "auto" | Spoken): string {
+  return language === "auto" ? `auto (${nativeNames[systemLanguage()]})` : nativeNames[language]
+}
+
+// The language the system's locale asks for.
+export function systemLanguage(): Spoken {
+  return (process.env.LC_ALL || process.env.LANG || "").startsWith("ja") ? "ja" : "en"
+}
+
+// What "auto" means here and now; any other choice stands as it is.
+export function resolveLanguage(language: "auto" | Spoken): Spoken {
+  return language === "auto" ? systemLanguage() : language
+}
+
+// The messages in use. It follows the system until the settings say otherwise.
+export let t: Messages = messages[systemLanguage()]
+
+export function useLanguage(language: "auto" | Spoken): void {
+  t = messages[resolveLanguage(language)]
+}
+
+export class Problem extends Error {
+  constructor(
+    readonly key: ProblemKey,
+    readonly detail = "",
+  ) {
+    super(key)
+  }
+}

package/src/log.ts

@@ -0,0 +1,72 @@
+import { constants } from "node:fs"
+import { type FileHandle, mkdir, open } from "node:fs/promises"
+import { dirname } from "node:path"
+import { paths } from "./app"
+
+export type LogEntry = { at: string; kind: string; [key: string]: unknown }
+
+export type SessionLog = {
+  id: string
+  path: string
+  append(entry: { kind: string; [key: string]: unknown }): Promise<void>
+  read(): Promise<LogEntry[]>
+}
+
+// Append-only JSONL: every message, every request sent to a model, and every event received, as they were.
+// Opening an existing session continues it.
+export async function openSessionLog(id: string = crypto.randomUUID()): Promise<SessionLog> {
+  if (!/^[A-Za-z0-9_-]+$/.test(id)) throw new Error("Invalid session id")
+  const path = paths.session(id)
+  const existing = await privateLog(path, constants.O_RDONLY)
+  await existing?.close()
+  return {
+    id,
+    path,
+    async append(entry) {
+      const file = (await privateLog(path, constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT))!
+      try {
+        await file.appendFile(`${JSON.stringify({ at: new Date().toISOString(), ...entry })}\n`)
+      } finally {
+        await file.close()
+      }
+    },
+    async read() {
+      const file = await privateLog(path, constants.O_RDONLY)
+      if (!file) return []
+      try {
+        const text = await file.readFile("utf8")
+        return text.split("\n").filter(Boolean).map((line) => JSON.parse(line) as LogEntry)
+      } finally {
+        await file.close()
+      }
+    },
+  }
+}
+
+// Tighten an existing log before reading or appending. Work on the opened file, never a link's target.
+async function privateLog(path: string, flags: number): Promise<FileHandle | undefined> {
+  const dir = dirname(path)
+  await mkdir(dir, { recursive: true, mode: 0o700 })
+  const directory = await open(dir, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW)
+  try {
+    await directory.chmod(0o700)
+  } finally {
+    await directory.close()
+  }
+  let file: FileHandle
+  try {
+    file = await open(path, flags | constants.O_NOFOLLOW | constants.O_NONBLOCK, 0o600)
+  } catch (error) {
+    if (!(flags & constants.O_CREAT) && (error as NodeJS.ErrnoException).code === "ENOENT") return
+    throw error
+  }
+  try {
+    const stat = await file.stat()
+    if (!stat.isFile() || stat.nlink !== 1) throw new Error("Session log must be a regular file with one link")
+    await file.chmod(0o600)
+    return file
+  } catch (error) {
+    await file.close()
+    throw error
+  }
+}