kimaki 0.4.21 → 0.4.22

package/src/format-tables.ts

@@ -0,0 +1,106 @@
+import { Lexer, type Token, type Tokens } from 'marked'
+
+export function formatMarkdownTables(markdown: string): string {
+  const lexer = new Lexer()
+  const tokens = lexer.lex(markdown)
+
+  let result = ''
+  for (const token of tokens) {
+    if (token.type === 'table') {
+      result += formatTableToken(token as Tokens.Table)
+    } else {
+      result += token.raw
+    }
+  }
+  return result
+}
+
+function formatTableToken(table: Tokens.Table): string {
+  const headers = table.header.map((cell) => {
+    return extractCellText(cell.tokens)
+  })
+  const rows = table.rows.map((row) => {
+    return row.map((cell) => {
+      return extractCellText(cell.tokens)
+    })
+  })
+
+  const columnWidths = calculateColumnWidths(headers, rows)
+  const lines: string[] = []
+
+  lines.push(formatRow(headers, columnWidths))
+  lines.push(formatSeparator(columnWidths))
+  for (const row of rows) {
+    lines.push(formatRow(row, columnWidths))
+  }
+
+  return '```\n' + lines.join('\n') + '\n```\n'
+}
+
+function extractCellText(tokens: Token[]): string {
+  const parts: string[] = []
+  for (const token of tokens) {
+    parts.push(extractTokenText(token))
+  }
+  return parts.join('').trim()
+}
+
+function extractTokenText(token: Token): string {
+  switch (token.type) {
+    case 'text':
+    case 'codespan':
+    case 'escape':
+      return token.text
+    case 'link':
+      return token.href
+    case 'image':
+      return token.href
+    case 'strong':
+    case 'em':
+    case 'del':
+      return token.tokens ? extractCellText(token.tokens) : token.text
+    case 'br':
+      return ' '
+    default: {
+      const tokenAny = token as { tokens?: Token[]; text?: string }
+      if (tokenAny.tokens && Array.isArray(tokenAny.tokens)) {
+        return extractCellText(tokenAny.tokens)
+      }
+      if (typeof tokenAny.text === 'string') {
+        return tokenAny.text
+      }
+      return ''
+    }
+  }
+}
+
+function calculateColumnWidths(
+  headers: string[],
+  rows: string[][],
+): number[] {
+  const widths = headers.map((h) => {
+    return h.length
+  })
+  for (const row of rows) {
+    for (let i = 0; i < row.length; i++) {
+      const cell = row[i] ?? ''
+      widths[i] = Math.max(widths[i] ?? 0, cell.length)
+    }
+  }
+  return widths
+}
+
+function formatRow(cells: string[], widths: number[]): string {
+  const paddedCells = cells.map((cell, i) => {
+    return cell.padEnd(widths[i] ?? 0)
+  })
+  return paddedCells.join(' ')
+}
+
+function formatSeparator(widths: number[]): string {
+  return widths
+    .map((w) => {
+      return '-'.repeat(w)
+    })
+    .join(' ')
+}

package/src/markdown.ts

@@ -1,6 +1,6 @@
 import type { OpencodeClient } from '@opencode-ai/sdk'
-import { format } from 'date-fns'
 import * as yaml from 'js-yaml'
+import { formatDateTime } from './utils.js'
 import { extractNonXmlContent } from './xml.js'
 
 export class ShareMarkdown {
@@ -62,10 +62,10 @@ export class ShareMarkdown {
         lines.push('## Session Information')
         lines.push('')
         lines.push(
-          `- **Created**: ${format(new Date(session.time.created), 'MMM d, yyyy, h:mm a')}`,
+          `- **Created**: ${formatDateTime(new Date(session.time.created))}`,
         )
         lines.push(
-          `- **Updated**: ${format(new Date(session.time.updated), 'MMM d, yyyy, h:mm a')}`,
+          `- **Updated**: ${formatDateTime(new Date(session.time.updated))}`,
         )
         if (session.version) {
           lines.push(`- **OpenCode Version**: v${session.version}`)

package/src/tools.ts

@@ -11,9 +11,9 @@ import {
 import { createLogger } from './logger.js'
 
 const toolsLogger = createLogger('TOOLS')
-import { formatDistanceToNow } from 'date-fns'
 
 import { ShareMarkdown } from './markdown.js'
+import { formatDistanceToNow } from './utils.js'
 import pc from 'picocolors'
 import {
   initializeOpencodeForDirectory,
@@ -232,9 +232,7 @@ export async function getTools({
             id: session.id,
             folder: session.directory,
             status,
-            finishedAt: formatDistanceToNow(new Date(finishedAt), {
-              addSuffix: true,
-            }),
+            finishedAt: formatDistanceToNow(new Date(finishedAt)),
             title: session.title,
             prompt: session.title,
           }

package/src/utils.ts

@@ -75,3 +75,40 @@ export function isAbortError(
     (error instanceof DOMException && error.name === 'AbortError')
   )
 }
+
+const rtf = new Intl.RelativeTimeFormat('en', { numeric: 'auto' })
+
+const TIME_DIVISIONS: Array<{ amount: number; name: Intl.RelativeTimeFormatUnit }> = [
+  { amount: 60, name: 'seconds' },
+  { amount: 60, name: 'minutes' },
+  { amount: 24, name: 'hours' },
+  { amount: 7, name: 'days' },
+  { amount: 4.34524, name: 'weeks' },
+  { amount: 12, name: 'months' },
+  { amount: Number.POSITIVE_INFINITY, name: 'years' },
+]
+
+export function formatDistanceToNow(date: Date): string {
+  let duration = (date.getTime() - Date.now()) / 1000
+
+  for (const division of TIME_DIVISIONS) {
+    if (Math.abs(duration) < division.amount) {
+      return rtf.format(Math.round(duration), division.name)
+    }
+    duration /= division.amount
+  }
+  return rtf.format(Math.round(duration), 'years')
+}
+
+const dtf = new Intl.DateTimeFormat('en-US', {
+  month: 'short',
+  day: 'numeric',
+  year: 'numeric',
+  hour: 'numeric',
+  minute: '2-digit',
+  hour12: true,
+})
+
+export function formatDateTime(date: Date): string {
+  return dtf.format(date)
+}