ikanban-web 0.2.6 → 0.2.8

package/src/context/highlights.tsx

@@ -1,208 +1,36 @@
-import { createEffect, createSignal, onCleanup } from "solid-js"
+import { createEffect, createSignal } from "solid-js"
 import { createStore } from "solid-js/store"
 import { createSimpleContext } from "ikanban-ui/context"
-import { useDialog } from "ikanban-ui/context/dialog"
 import { usePlatform } from "@/context/platform"
-import { useSettings } from "@/context/settings"
 import { persisted } from "@/utils/persist"
-import { DialogReleaseNotes, type Highlight } from "@/components/dialog-release-notes"
-
-const CHANGELOG_URL = "https://opencode.ai/changelog.json"
 
 type Store = {
   version?: string
 }
 
-type ParsedRelease = {
-  tag?: string
-  highlights: Highlight[]
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value)
-}
-
-function getText(value: unknown): string | undefined {
-  if (typeof value === "string") {
-    const text = value.trim()
-    return text.length > 0 ? text : undefined
-  }
-
-  if (typeof value === "number") return String(value)
-  return
-}
-
-function normalizeVersion(value: string | undefined) {
-  const text = value?.trim()
-  if (!text) return
-  return text.startsWith("v") || text.startsWith("V") ? text.slice(1) : text
-}
-
-function parseMedia(value: unknown, alt: string): Highlight["media"] | undefined {
-  if (!isRecord(value)) return
-  const type = getText(value.type)?.toLowerCase()
-  const src = getText(value.src) ?? getText(value.url)
-  if (!src) return
-  if (type !== "image" && type !== "video") return
-
-  return { type, src, alt }
-}
-
-function parseHighlight(value: unknown): Highlight | undefined {
-  if (!isRecord(value)) return
-
-  const title = getText(value.title)
-  if (!title) return
-
-  const description = getText(value.description) ?? getText(value.shortDescription)
-  if (!description) return
-
-  const media = parseMedia(value.media, title)
-  return { title, description, media }
-}
-
-function parseRelease(value: unknown): ParsedRelease | undefined {
-  if (!isRecord(value)) return
-  const tag = getText(value.tag) ?? getText(value.tag_name) ?? getText(value.name)
-
-  if (!Array.isArray(value.highlights)) {
-    return { tag, highlights: [] }
-  }
-
-  const highlights = value.highlights.flatMap((group) => {
-    if (!isRecord(group)) return []
-
-    const source = getText(group.source)
-    if (!source) return []
-    if (!source.toLowerCase().includes("desktop")) return []
-
-    if (Array.isArray(group.items)) {
-      return group.items.map((item) => parseHighlight(item)).filter((item): item is Highlight => item !== undefined)
-    }
-
-    const item = parseHighlight(group)
-    if (!item) return []
-    return [item]
-  })
-
-  return { tag, highlights }
-}
-
-function parseChangelog(value: unknown): ParsedRelease[] | undefined {
-  if (Array.isArray(value)) {
-    return value.map(parseRelease).filter((release): release is ParsedRelease => release !== undefined)
-  }
-
-  if (!isRecord(value)) return
-  if (!Array.isArray(value.releases)) return
-
-  return value.releases.map(parseRelease).filter((release): release is ParsedRelease => release !== undefined)
-}
-
-function sliceHighlights(input: { releases: ParsedRelease[]; current?: string; previous?: string }) {
-  const current = normalizeVersion(input.current)
-  const previous = normalizeVersion(input.previous)
-  const releases = input.releases
-
-  const start = (() => {
-    if (!current) return 0
-    const index = releases.findIndex((release) => normalizeVersion(release.tag) === current)
-    return index === -1 ? 0 : index
-  })()
-
-  const end = (() => {
-    if (!previous) return releases.length
-    const index = releases.findIndex((release, i) => i >= start && normalizeVersion(release.tag) === previous)
-    return index === -1 ? releases.length : index
-  })()
-
-  const highlights = releases.slice(start, end).flatMap((release) => release.highlights)
-  const seen = new Set<string>()
-  const unique = highlights.filter((highlight) => {
-    const key = dedupeKey(highlight)
-    if (seen.has(key)) return false
-    seen.add(key)
-    return true
-  })
-  return unique.slice(0, 5)
-}
-
-function dedupeKey(highlight: Highlight) {
-  return [highlight.title, highlight.description, highlight.media?.type ?? "", highlight.media?.src ?? ""].join("\n")
-}
-
-function loadReleaseHighlights(value: unknown, current?: string, previous?: string) {
-  const releases = parseChangelog(value)
-  if (!releases?.length) return []
-  return sliceHighlights({ releases, current, previous })
-}
-
 export const { use: useHighlights, provider: HighlightsProvider } = createSimpleContext({
   name: "Highlights",
   gate: false,
   init: () => {
     const platform = usePlatform()
-    const dialog = useDialog()
-    const settings = useSettings()
     const [store, setStore, _, ready] = persisted("highlights.v1", createStore<Store>({ version: undefined }))
 
     const [from, setFrom] = createSignal<string | undefined>(undefined)
     const [to, setTo] = createSignal<string | undefined>(undefined)
     const state = { started: false }
-    let timer: ReturnType<typeof setTimeout> | undefined
-
-    const clearTimer = () => {
-      if (timer === undefined) return
-      clearTimeout(timer)
-      timer = undefined
-    }
-
     const markSeen = () => {
       if (!platform.version) return
       setStore("version", platform.version)
     }
 
-    const start = (previous: string) => {
-      if (!settings.general.releaseNotes()) {
-        markSeen()
-        return
-      }
-
-      const fetcher = platform.fetch ?? fetch
-      const controller = new AbortController()
-      onCleanup(() => {
-        controller.abort()
-        clearTimer()
-      })
-
-      fetcher(CHANGELOG_URL, {
-        signal: controller.signal,
-        headers: { Accept: "application/json" },
-      })
-        .then((response) => (response.ok ? (response.json() as Promise<unknown>) : undefined))
-        .then((json) => {
-          if (!json) return
-          const highlights = loadReleaseHighlights(json, platform.version, previous)
-          if (controller.signal.aborted) return
-
-          if (highlights.length === 0) {
-            markSeen()
-            return
-          }
-
-          timer = setTimeout(() => {
-            timer = undefined
-            markSeen()
-            dialog.show(() => <DialogReleaseNotes highlights={highlights} />)
-          }, 500)
-        })
-        .catch(() => undefined)
+    const start = (_previous: string) => {
+      // Updates and release-note prompts are temporarily disabled.
+      markSeen()
     }
 
     createEffect(() => {
       if (state.started) return
       if (!ready()) return
-      if (!settings.ready()) return
       if (!platform.version) return
       state.started = true
 

package/src/context/server.tsx

@@ -102,6 +102,7 @@ export const { use: useServer, provider: ServerProvider } = createSimpleContext(
       Persist.global("server", ["server.v3"]),
       createStore({
         list: [] as StoredServer[],
+        deleted: [] as ServerConnection.Key[],
         projects: {} as Record<string, StoredProject[]>,
         lastProject: {} as Record<string, string>,
       }),
@@ -110,8 +111,9 @@ export const { use: useServer, provider: ServerProvider } = createSimpleContext(
     const url = (x: StoredServer) => (typeof x === "string" ? x : "type" in x ? x.http.url : x.url)
 
     const allServers = createMemo((): Array<ServerConnection.Any> => {
+      const deletedSet = new Set(store.deleted)
       const servers = [
-        ...(props.servers ?? []),
+        ...(props.servers ?? []).filter((s) => !deletedSet.has(ServerConnection.key(s))),
         ...store.list.map((value) =>
           typeof value === "string"
             ? {
@@ -172,6 +174,7 @@ export const { use: useServer, provider: ServerProvider } = createSimpleContext(
       const url_ = normalizeServerUrl(input.http.url)
       if (!url_) return
       const conn = { ...input, http: { ...input.http, url: url_ } }
+      const connKey = ServerConnection.key(conn)
       return batch(() => {
         const existing = store.list.findIndex((x) => url(x) === url_)
         if (existing !== -1) {
@@ -179,18 +182,35 @@ export const { use: useServer, provider: ServerProvider } = createSimpleContext(
         } else {
           setStore("list", store.list.length, conn)
         }
-        setState("active", ServerConnection.key(conn))
+        // If this server was previously deleted, un-delete it
+        if (store.deleted.includes(connKey)) {
+          setStore("deleted", store.deleted.filter((k) => k !== connKey))
+        }
+        setState("active", connKey)
         return conn
       })
     }
 
     function remove(key: ServerConnection.Key) {
       const list = store.list.filter((x) => url(x) !== key)
+      const isPropServer = (props.servers ?? []).some((s) => ServerConnection.key(s) === key)
       batch(() => {
         setStore("list", list)
+        // If it's a prop-injected server, record it as deleted so it stays gone after reload
+        if (isPropServer && !store.deleted.includes(key)) {
+          setStore("deleted", [...store.deleted, key])
+        }
         if (state.active === key) {
-          const next = list[0]
-          setState("active", next ? ServerConnection.Key.make(url(next)) : props.defaultServer)
+          const nextStored = list[0]
+          const nextProp = (props.servers ?? []).find(
+            (s) => !store.deleted.includes(ServerConnection.key(s)) && ServerConnection.key(s) !== key,
+          )
+          const nextKey = nextStored
+            ? ServerConnection.Key.make(url(nextStored))
+            : nextProp
+              ? ServerConnection.key(nextProp)
+              : props.defaultServer
+          setState("active", nextKey)
         }
       })
     }

package/src/context/sync.tsx

@@ -1,11 +1,180 @@
 import { batch, createMemo } from "solid-js"
-import { createStore, produce, reconcile } from "solid-js/store"
+import { createStore, produce, reconcile, type SetStoreFunction } from "solid-js/store"
 import { Binary } from "ikanban-utils/binary"
 import { retry } from "ikanban-utils/retry"
 import { createSimpleContext } from "ikanban-ui/context"
+import { applyPatch, parsePatch, reversePatch, type StructuredPatch } from "diff"
 import { useGlobalSync } from "./global-sync"
 import { useSDK } from "./sdk"
-import type { Message, Part } from "@opencode-ai/sdk/v2/client"
+import type { File as SDKFile, FileContent, FileDiff, Message, Part } from "@opencode-ai/sdk/v2/client"
+
+type ProjectDiffEntry = FileDiff & {
+  lazy?: boolean
+  loading?: boolean
+  binary?: boolean
+}
+
+const PROJECT_DIFF_INITIAL_READ_LIMIT = 20
+const PROJECT_DIFF_READ_CONCURRENCY = 4
+const PROJECT_DIFF_MAX_EAGER_CHANGED_LINES = 400
+const BINARY_FILE_RE = /\.(?:png|jpe?g|gif|webp|bmp|ico|avif|mp3|wav|ogg|flac|mp4|mov|avi|mkv|webm|pdf|zip|gz|tar|7z|woff2?|ttf|eot|otf|exe|bin|so|dylib|dll|class|jar|wasm)$/i
+
+function isLikelyBinaryPath(path: string) {
+  return BINARY_FILE_RE.test(path)
+}
+
+function createProjectPlaceholder(file: SDKFile, input: { lazy?: boolean; loading?: boolean; binary?: boolean } = {}): ProjectDiffEntry {
+  return {
+    file: file.path,
+    before: "",
+    after: "",
+    additions: file.added,
+    deletions: file.removed,
+    status: file.status,
+    lazy: input.lazy,
+    loading: input.loading,
+    binary: input.binary,
+  }
+}
+
+function shouldEagerLoadProjectDiff(file: SDKFile) {
+  if (isLikelyBinaryPath(file.path)) return false
+  if (file.added + file.removed > PROJECT_DIFF_MAX_EAGER_CHANGED_LINES) return false
+  return true
+}
+
+function getStructuredPatch(content?: FileContent): StructuredPatch | undefined {
+  if (!content) return
+  if (content.diff) {
+    const parsed = parsePatch(content.diff)[0]
+    if (parsed) return parsed
+  }
+  if (!content.patch) return
+  return {
+    oldFileName: content.patch.oldFileName,
+    newFileName: content.patch.newFileName,
+    oldHeader: content.patch.oldHeader,
+    newHeader: content.patch.newHeader,
+    hunks: content.patch.hunks.map((hunk) => ({
+      oldStart: hunk.oldStart,
+      oldLines: hunk.oldLines,
+      newStart: hunk.newStart,
+      newLines: hunk.newLines,
+      lines: [...hunk.lines],
+    })),
+  }
+}
+
+function buildWorkspaceDiff(file: SDKFile, content?: FileContent): ProjectDiffEntry | undefined {
+  const patch = getStructuredPatch(content)
+
+  if (content?.type === "binary") {
+    return createProjectPlaceholder(file, { binary: true })
+  }
+
+  if (file.status === "added") {
+    const after = content?.content ?? (patch ? applyPatch("", patch) || "" : "")
+    return {
+      file: file.path,
+      before: "",
+      after,
+      additions: file.added,
+      deletions: file.removed,
+      status: file.status,
+    }
+  }
+
+  if (file.status === "deleted") {
+    const before = content?.content ?? (patch ? applyPatch("", reversePatch(patch)) || "" : "")
+    return {
+      file: file.path,
+      before,
+      after: "",
+      additions: file.added,
+      deletions: file.removed,
+      status: file.status,
+    }
+  }
+
+  const after = content?.content ?? ""
+  const before = patch ? applyPatch(after, reversePatch(patch)) || after : after
+
+  if (!patch && file.added + file.removed === 0) return
+
+  return {
+    file: file.path,
+    before,
+    after,
+    additions: file.added,
+    deletions: file.removed,
+    status: file.status,
+  }
+}
+
+async function fetchProjectDiffs(client: ReturnType<typeof useSDK>["client"], directory: string): Promise<FileDiff[]> {
+  const files = await retry(() => client.file.status({ directory })).then((result) => result.data ?? [])
+  return files.map((file) =>
+    createProjectPlaceholder(file, {
+      lazy: !shouldEagerLoadProjectDiff(file),
+      loading: false,
+    }),
+  )
+}
+
+async function hydrateProjectDiffFile(
+  client: ReturnType<typeof useSDK>["client"],
+  directory: string,
+  file: SDKFile,
+): Promise<ProjectDiffEntry> {
+  const content = await retry(() => client.file.read({ path: file.path, directory }))
+    .then((result) => result.data)
+    .catch(() => undefined)
+  return buildWorkspaceDiff(file, content) ?? createProjectPlaceholder(file)
+}
+
+function updateProjectDiffEntry(
+  setStore: SetStoreFunction<any>,
+  directory: string,
+  path: string,
+  updater: (current: ProjectDiffEntry) => ProjectDiffEntry,
+) {
+  setStore(
+    "project_diff",
+    directory,
+    produce((draft: ProjectDiffEntry[]) => {
+      const index = draft.findIndex((item) => item.file === path)
+      if (index === -1) return
+      draft[index] = updater(draft[index])
+    }),
+  )
+}
+
+async function hydrateProjectDiffBatch(input: {
+  client: ReturnType<typeof useSDK>["client"]
+  directory: string
+  setStore: SetStoreFunction<any>
+  entries: ProjectDiffEntry[]
+}) {
+  for (let i = 0; i < input.entries.length; i += PROJECT_DIFF_READ_CONCURRENCY) {
+    const chunk = input.entries.slice(i, i + PROJECT_DIFF_READ_CONCURRENCY)
+    await Promise.all(
+      chunk.map(async (entry) => {
+        const file: SDKFile = {
+          path: entry.file,
+          added: entry.additions,
+          removed: entry.deletions,
+          status: entry.status ?? "modified",
+        }
+        const hydrated = await hydrateProjectDiffFile(input.client, input.directory, file)
+        updateProjectDiffEntry(input.setStore, input.directory, entry.file, () => ({
+          ...hydrated,
+          lazy: false,
+          loading: false,
+        }))
+      }),
+    )
+  }
+}
 
 function sortParts(parts: Part[]) {
   return parts.filter((part) => !!part?.id).sort((a, b) => cmp(a.id, b.id))
@@ -107,6 +276,7 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
     const messagePageSize = 200
     const inflight = new Map<string, Promise<void>>()
     const inflightDiff = new Map<string, Promise<void>>()
+    const inflightProjectFile = new Map<string, Promise<void>>()
     const inflightTodo = new Map<string, Promise<void>>()
     const [meta, setMeta] = createStore({
       limit: {} as Record<string, number>,
@@ -350,6 +520,71 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
           )
         },
       },
+      projectDiff: {
+        async diff() {
+          const directory = sdk.directory
+          const client = sdk.client
+          const [store, setStore] = globalSync.child(directory)
+          if (store.project_diff[directory] !== undefined) return
+
+          const key = `project\n${directory}`
+          return runInflight(inflightDiff, key, async () => {
+            const diff = (await fetchProjectDiffs(client, directory)) as ProjectDiffEntry[]
+            const eagerFiles = new Set(
+              diff
+                .filter((entry) => !entry.lazy)
+                .slice(0, PROJECT_DIFF_INITIAL_READ_LIMIT)
+                .map((entry) => entry.file),
+            )
+            const seeded = diff.map((entry) => ({
+              ...entry,
+              lazy: entry.lazy || !eagerFiles.has(entry.file),
+              loading: eagerFiles.has(entry.file),
+            }))
+            setStore("project_diff", directory, reconcile(seeded, { key: "file" }))
+
+            const eager = seeded.filter((entry) => eagerFiles.has(entry.file))
+
+            if (!eager.length) return
+
+            await hydrateProjectDiffBatch({
+              client,
+              directory,
+              setStore,
+              entries: eager,
+            })
+          })
+        },
+        hydrate(path: string) {
+          const directory = sdk.directory
+          const client = sdk.client
+          const [store, setStore] = globalSync.child(directory)
+          const entries = store.project_diff[directory] as ProjectDiffEntry[] | undefined
+          const existing = entries?.find((item) => item.file === path)
+          if (!existing || (!existing.lazy && !existing.loading)) return
+
+          const fileKey = `project-file\n${directory}\n${path}`
+          return runInflight(inflightProjectFile, fileKey, async () => {
+            updateProjectDiffEntry(setStore, directory, path, (current) => ({
+              ...current,
+              loading: true,
+            }))
+
+            const file: SDKFile = {
+              path: existing.file,
+              added: existing.additions,
+              removed: existing.deletions,
+              status: existing.status ?? "modified",
+            }
+            const hydrated = await hydrateProjectDiffFile(client, directory, file)
+            updateProjectDiffEntry(setStore, directory, path, () => ({
+              ...hydrated,
+              lazy: false,
+              loading: false,
+            }))
+          })
+        },
+      },
       absolute,
       get directory() {
         return current()[0].path.directory

package/src/i18n/en.ts

@@ -23,6 +23,7 @@ export const dict = {
 
   "command.sidebar.toggle": "Toggle sidebar",
   "command.project.open": "Open project",
+  "command.project.close": "Close project",
   "command.provider.connect": "Connect provider",
   "command.server.switch": "Switch server",
   "command.settings.open": "Open settings",
@@ -77,6 +78,8 @@ export const dict = {
   "command.workspace.toggle.description": "Enable or disable multiple workspaces in the sidebar",
   "command.session.undo": "Undo",
   "command.session.undo.description": "Undo the last message",
+  "command.session.timeline": "Timeline",
+  "command.session.timeline.description": "Jump to any message in this session timeline",
   "command.session.redo": "Redo",
   "command.session.redo.description": "Redo the last undone message",
   "command.session.compact": "Compact session",
@@ -303,6 +306,8 @@ export const dict = {
   "mcp.status.disabled": "disabled",
 
   "dialog.fork.empty": "No messages to fork from",
+  "dialog.timeline.empty": "No messages in this timeline",
+  "dialog.timeline.latest": "Latest message",
 
   "dialog.directory.search.placeholder": "Search folders",
   "dialog.directory.empty": "No folders found",
@@ -513,6 +518,8 @@ export const dict = {
   "session.review.loadingChanges": "Loading changes...",
   "session.review.empty": "No changes in this session yet",
   "session.review.noVcs": "No git VCS detected, so session changes will not be detected",
+  "session.review.emptyProject": "No project changes yet",
+  "session.review.noVcsProject": "No git VCS detected, so project changes will not be detected",
   "session.review.noChanges": "No changes",
 
   "session.files.selectToOpen": "Select a file to open",
@@ -610,7 +617,7 @@ export const dict = {
   "sidebar.project.viewAllSessions": "View all sessions",
   "sidebar.project.clearNotifications": "Clear notifications",
 
-  "app.name.desktop": "OpenCode Desktop",
+  "app.name.desktop": "iKanban",
 
   "settings.section.desktop": "Desktop",
   "settings.section.server": "Server",
@@ -624,6 +631,7 @@ export const dict = {
   "settings.general.section.notifications": "System notifications",
   "settings.general.section.updates": "Updates",
   "settings.general.section.sounds": "Sound effects",
+  "settings.general.section.releaseNotes": "Release notes",
   "settings.general.section.feed": "Feed",
   "settings.general.section.display": "Display",
 
@@ -651,6 +659,9 @@ export const dict = {
 
   "settings.general.row.releaseNotes.title": "Release notes",
   "settings.general.row.releaseNotes.description": "Show What's New popups after updates",
+  "settings.general.row.releaseNotesCurrent.title": "Current version changes",
+  "settings.general.row.releaseNotesCurrent.description": "Open this version's changelog entries on GitHub",
+  "settings.general.action.releaseNotesCurrent": "View changes",
 
   "settings.updates.row.startup.title": "Check for updates on startup",
   "settings.updates.row.startup.description": "Automatically check for updates when OpenCode launches",

package/src/i18n/parity.test.ts

@@ -1,32 +1,14 @@
 import { describe, expect, test } from "bun:test"
 import { dict as en } from "./en"
-import { dict as ar } from "./ar"
-import { dict as br } from "./br"
-import { dict as bs } from "./bs"
-import { dict as da } from "./da"
-import { dict as de } from "./de"
-import { dict as es } from "./es"
-import { dict as fr } from "./fr"
-import { dict as ja } from "./ja"
-import { dict as ko } from "./ko"
-import { dict as no } from "./no"
-import { dict as pl } from "./pl"
-import { dict as ru } from "./ru"
-import { dict as th } from "./th"
 import { dict as zh } from "./zh"
-import { dict as zht } from "./zht"
-import { dict as tr } from "./tr"
 
-const locales = [ar, br, bs, da, de, es, fr, ja, ko, no, pl, ru, th, tr, zh, zht]
 const keys = ["command.session.previous.unseen", "command.session.next.unseen"] as const
 
 describe("i18n parity", () => {
-  test("non-English locales translate targeted unseen session keys", () => {
-    for (const locale of locales) {
-      for (const key of keys) {
-        expect(locale[key]).toBeDefined()
-        expect(locale[key]).not.toBe(en[key])
-      }
+  test("zh translates targeted unseen session keys", () => {
+    for (const key of keys) {
+      expect(zh[key]).toBeDefined()
+      expect(zh[key]).not.toBe(en[key])
     }
   })
 })