typeclaw 0.22.0 → 0.24.0

package/src/channels/adapters/github/review-thread-resolver.ts

@@ -0,0 +1,246 @@
+import type { ReviewThreadResolveRequest, ReviewThreadResolveResult, ReviewThreadResolver } from '@/channels/types'
+
+import type { GithubAuthContext } from './auth'
+import { GITHUB_API_BASE, githubJsonHeaders } from './auth-pat'
+
+const GRAPHQL_ENDPOINT = `${GITHUB_API_BASE}/graphql`
+
+// One page of review threads. `first: 100` is the GraphQL max; a busy PR can
+// carry more, so the resolver paginates until it matches the root comment id
+// or exhausts the pages — stopping early on a 404-equivalent (thread absent)
+// rather than fabricating a node id.
+const THREADS_QUERY = `query($owner:String!,$name:String!,$number:Int!,$after:String){repository(owner:$owner,name:$name){pullRequest(number:$number){reviewThreads(first:100,after:$after){pageInfo{hasNextPage endCursor}nodes{id isResolved comments(first:1){nodes{databaseId author{login}}}}}}}}`
+
+const RESOLVE_MUTATION = `mutation($threadId:ID!){resolveReviewThread(input:{threadId:$threadId}){thread{id isResolved}}}`
+
+type ReviewThreadNode = {
+  id: string
+  isResolved: boolean
+  rootCommentId: number | null
+  rootAuthorLogin: string | null
+}
+
+type ThreadLookup =
+  | { kind: 'found'; thread: ReviewThreadNode }
+  | { kind: 'absent' }
+  | { kind: 'error'; result: ReviewThreadResolveResult & { ok: false } }
+
+export function createGithubReviewThreadResolver(deps: {
+  token: (context?: GithubAuthContext) => Promise<string>
+  selfLogin: () => string | null
+  fetchImpl?: typeof fetch
+}): ReviewThreadResolver {
+  const fetchImpl = deps.fetchImpl ?? fetch
+  return async (req): Promise<ReviewThreadResolveResult> => {
+    if (req.adapter !== 'github') {
+      return { ok: false, error: `unknown adapter: ${req.adapter}`, code: 'unsupported' }
+    }
+    const target = parseTarget(req)
+    if (target === null) {
+      return {
+        ok: false,
+        error: `unparseable github review-thread target (chat=${req.chat}, root=${req.rootCommentId})`,
+        code: 'transient',
+      }
+    }
+    const selfLogin = deps.selfLogin()
+    if (selfLogin === null) {
+      return {
+        ok: false,
+        error: 'github self-identity not resolved; cannot verify thread authorship',
+        code: 'transient',
+      }
+    }
+
+    const token = await deps.token({ repoSlug: `${target.owner}/${target.repo}` })
+    const lookup = await findThread(fetchImpl, token, target)
+    if (lookup.kind === 'error') return lookup.result
+    if (lookup.kind === 'absent') {
+      return {
+        ok: false,
+        error: `no review thread rooted at comment ${target.rootCommentId} on ${req.chat}`,
+        code: 'no-match',
+      }
+    }
+
+    const thread = lookup.thread
+    // The load-bearing guard: only the bot may resolve the bot's own thread.
+    // Resolving a human reviewer's thread would erase their open question.
+    if (thread.rootAuthorLogin !== selfLogin) {
+      return {
+        ok: false,
+        error: `refusing to resolve thread authored by @${thread.rootAuthorLogin ?? 'unknown'} (not @${selfLogin})`,
+        code: 'not-author',
+      }
+    }
+    if (thread.isResolved) return { ok: true, alreadyResolved: true }
+
+    return await runResolveMutation(fetchImpl, token, thread.id)
+  }
+}
+
+type ResolveTarget = { owner: string; repo: string; prNumber: number; rootCommentId: number }
+
+function parseTarget(req: ReviewThreadResolveRequest): ResolveTarget | null {
+  const [owner, repo, ...rest] = req.workspace.split('/')
+  if (owner === undefined || owner === '' || repo === undefined || repo === '' || rest.length > 0) return null
+  const prMatch = /^pr:(\d+)$/.exec(req.chat)
+  if (prMatch === null) return null
+  const prNumber = parseDecimalId(prMatch[1])
+  const rootCommentId = parseDecimalId(req.rootCommentId)
+  if (prNumber === null || rootCommentId === null) return null
+  return { owner, repo, prNumber, rootCommentId }
+}
+
+// Strict decimal-id parse: `Number()` would coerce '' -> 0, '1e2' -> 100, and
+// silently round ids past 2^53 (GitHub comment ids are large), any of which
+// could match the WRONG thread. Demand a plain run of digits and a safe
+// integer, so a malformed or oversized id fails closed (no resolution) rather
+// than resolving a collided thread.
+function parseDecimalId(value: string | undefined): number | null {
+  if (value === undefined || !/^\d+$/.test(value)) return null
+  const n = Number(value)
+  return Number.isSafeInteger(n) ? n : null
+}
+
+async function findThread(fetchImpl: typeof fetch, token: string, target: ResolveTarget): Promise<ThreadLookup> {
+  let after: string | null = null
+  for (;;) {
+    let response: Response
+    try {
+      response = await fetchImpl(GRAPHQL_ENDPOINT, {
+        method: 'POST',
+        headers: githubJsonHeaders(token),
+        body: JSON.stringify({
+          query: THREADS_QUERY,
+          variables: { owner: target.owner, name: target.repo, number: target.prNumber, after },
+        }),
+      })
+    } catch (err) {
+      return {
+        kind: 'error',
+        result: { ok: false, error: err instanceof Error ? err.message : String(err), code: 'transient' },
+      }
+    }
+    const parsed = await parseThreadsPage(response)
+    if (parsed.kind === 'error') return { kind: 'error', result: parsed.result }
+
+    for (const node of parsed.nodes) {
+      if (node.rootCommentId === target.rootCommentId) return { kind: 'found', thread: node }
+    }
+    if (!parsed.hasNextPage || parsed.endCursor === null) return { kind: 'absent' }
+    after = parsed.endCursor
+  }
+}
+
+type ThreadsPage =
+  | { kind: 'ok'; nodes: ReviewThreadNode[]; hasNextPage: boolean; endCursor: string | null }
+  | { kind: 'error'; result: ReviewThreadResolveResult & { ok: false } }
+
+async function parseThreadsPage(response: Response): Promise<ThreadsPage> {
+  if (!response.ok) {
+    const text = await response.text().catch(() => '')
+    return {
+      kind: 'error',
+      result: {
+        ok: false,
+        error: `GitHub GraphQL ${response.status}${text !== '' ? `: ${text}` : ''}`,
+        code: classifyStatus(response.status),
+      },
+    }
+  }
+  const body = (await response.json().catch(() => null)) as GraphqlThreadsResponse | null
+  if (body === null)
+    return { kind: 'error', result: { ok: false, error: 'GitHub GraphQL returned non-JSON', code: 'transient' } }
+  if (body.errors !== undefined && body.errors.length > 0) {
+    return {
+      kind: 'error',
+      result: {
+        ok: false,
+        error: `GitHub GraphQL error: ${body.errors.map((e) => e.message).join('; ')}`,
+        code: 'transient',
+      },
+    }
+  }
+  const connection = body.data?.repository?.pullRequest?.reviewThreads
+  if (connection === undefined)
+    return {
+      kind: 'error',
+      result: { ok: false, error: 'GitHub GraphQL response missing reviewThreads', code: 'transient' },
+    }
+  const nodes = connection.nodes.map((n) => {
+    const root = n.comments.nodes[0]
+    return {
+      id: n.id,
+      isResolved: n.isResolved,
+      rootCommentId: root?.databaseId ?? null,
+      rootAuthorLogin: root?.author?.login ?? null,
+    }
+  })
+  return { kind: 'ok', nodes, hasNextPage: connection.pageInfo.hasNextPage, endCursor: connection.pageInfo.endCursor }
+}
+
+async function runResolveMutation(
+  fetchImpl: typeof fetch,
+  token: string,
+  threadId: string,
+): Promise<ReviewThreadResolveResult> {
+  let response: Response
+  try {
+    response = await fetchImpl(GRAPHQL_ENDPOINT, {
+      method: 'POST',
+      headers: githubJsonHeaders(token),
+      body: JSON.stringify({ query: RESOLVE_MUTATION, variables: { threadId } }),
+    })
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err), code: 'transient' }
+  }
+  if (!response.ok) {
+    const text = await response.text().catch(() => '')
+    return {
+      ok: false,
+      error: `GitHub GraphQL ${response.status}${text !== '' ? `: ${text}` : ''}`,
+      code: classifyStatus(response.status),
+    }
+  }
+  const body = (await response.json().catch(() => null)) as GraphqlResolveResponse | null
+  if (body === null) return { ok: false, error: 'GitHub GraphQL returned non-JSON', code: 'transient' }
+  if (body.errors !== undefined && body.errors.length > 0) {
+    return {
+      ok: false,
+      error: `GitHub GraphQL error: ${body.errors.map((e) => e.message).join('; ')}`,
+      code: 'transient',
+    }
+  }
+  if (body.data?.resolveReviewThread?.thread?.isResolved === true) return { ok: true }
+  return { ok: false, error: 'resolveReviewThread mutation did not report isResolved', code: 'transient' }
+}
+
+function classifyStatus(status: number): 'permission-denied' | 'not-found' | 'transient' {
+  if (status === 401 || status === 403) return 'permission-denied'
+  if (status === 404) return 'not-found'
+  return 'transient'
+}
+
+type GraphqlThreadsResponse = {
+  data?: {
+    repository?: {
+      pullRequest?: {
+        reviewThreads?: {
+          pageInfo: { hasNextPage: boolean; endCursor: string | null }
+          nodes: Array<{
+            id: string
+            isResolved: boolean
+            comments: { nodes: Array<{ databaseId?: number; author?: { login?: string } }> }
+          }>
+        }
+      }
+    }
+  }
+  errors?: Array<{ message: string }>
+}
+
+type GraphqlResolveResponse = {
+  data?: { resolveReviewThread?: { thread?: { id: string; isResolved: boolean } } }
+  errors?: Array<{ message: string }>
+}

package/src/channels/adapters/kakaotalk-classify.ts

@@ -1,8 +1,8 @@
-import type { KakaoTalkPushMessageEvent } from 'agent-messenger/kakaotalk'
+import { KAKAO_MESSAGE_TYPE, type KakaoTalkPushMessageEvent } from 'agent-messenger/kakaotalk'
 
 import { matchesAnyAlias } from '@/channels/engagement'
 import type { ChannelAdapterConfig } from '@/channels/schema'
-import type { InboundAttachment, InboundMessage } from '@/channels/types'
+import type { InboundAttachment, InboundMessage, InboundReferenceContext } from '@/channels/types'
 
 export type InboundDropReason = 'self_author' | 'empty_text' | 'unknown_chat' | 'pre_connect' | 'bot_message'
 
@@ -49,7 +49,9 @@ export function classifyInbound(
     return { kind: 'drop', reason: 'bot_message' }
   }
 
-  const text = event.message ?? ''
+  const rawText = event.message ?? ''
+  const replyContext = parseReplyContext(event, context.selfUserId)
+  const text = rawText
   if (text === '') return { kind: 'drop', reason: 'empty_text' }
 
   const chatInfo = context.lookupChat(event.chat_id)
@@ -64,7 +66,7 @@ export function classifyInbound(
   // mention (see engagement.ts: alias is unconditional and ranks alongside
   // explicit triggers). Without aliases configured, only `reply` and `dm`
   // triggers can fire on KakaoTalk.
-  const aliasMatched = matchesAnyAlias(text, context.selfAliases ?? [])
+  const aliasMatched = matchesAnyAlias(rawText, context.selfAliases ?? [])
 
   return {
     kind: 'route',
@@ -74,6 +76,7 @@ export function classifyInbound(
       chat: event.chat_id,
       thread: null,
       text,
+      ...referenceContextPayload(replyContext),
       ...(context.attachments !== undefined && context.attachments.length > 0
         ? { attachments: context.attachments }
         : {}),
@@ -82,9 +85,9 @@ export function classifyInbound(
       authorName: event.author_name ?? String(event.author_id),
       authorIsBot: false,
       isBotMention: aliasMatched,
-      replyToBotMessageId: null,
+      replyToBotMessageId: replyContext?.target === 'bot' ? replyContext.logId : null,
       mentionsOthers: false,
-      replyToOtherMessageId: null,
+      replyToOtherMessageId: replyContext?.target === 'other' ? replyContext.logId : null,
       isDm: chatInfo.isDm,
       // SDK delivers `sent_at` in Unix seconds (LOCO `sendAt`); contract
       // wants ms (see `src/channels/types.ts`). Without `* 1000`, ms-based
@@ -93,3 +96,61 @@ export function classifyInbound(
     },
   }
 }
+
+type ParsedReplyContext = {
+  logId: string
+  authorId: string
+  authorName: string
+  quotedText: string | null
+  target: 'bot' | 'other'
+}
+
+function parseReplyContext(event: KakaoTalkPushMessageEvent, selfUserId: string): ParsedReplyContext | null {
+  if (event.message_type !== KAKAO_MESSAGE_TYPE.REPLY) return null
+  if (event.attachment === null) return null
+
+  const logId = stringField(event.attachment, 'src_logId')
+  const sourceUserId = numericField(event.attachment, 'src_userId')
+  if (logId === null || sourceUserId === null) return null
+
+  const sourceAuthorId = String(sourceUserId)
+  const quotedText = stringField(event.attachment, 'src_message')
+  return {
+    logId,
+    authorId: sourceAuthorId,
+    // classifyInbound is synchronous and has no cheap author resolver access;
+    // fall back to Kakao's stable source user id rather than fetching.
+    authorName: sourceAuthorId,
+    quotedText,
+    target: sourceAuthorId === selfUserId ? 'bot' : 'other',
+  }
+}
+
+function referenceContextPayload(
+  replyContext: ParsedReplyContext | null,
+): { referenceContext: InboundReferenceContext } | Record<string, never> {
+  if (replyContext === null || replyContext.quotedText === null || replyContext.quotedText.trim() === '') return {}
+  return {
+    referenceContext: {
+      kind: 'reply',
+      sources: [
+        {
+          adapter: 'kakaotalk',
+          authorId: replyContext.authorId,
+          authorName: replyContext.authorName,
+          text: replyContext.quotedText,
+        },
+      ],
+    },
+  }
+}
+
+function stringField(record: Record<string, unknown>, key: string): string | null {
+  const value = record[key]
+  return typeof value === 'string' && value.length > 0 ? value : null
+}
+
+function numericField(record: Record<string, unknown>, key: string): number | null {
+  const value = record[key]
+  return typeof value === 'number' && Number.isFinite(value) ? value : null
+}

package/src/channels/adapters/slack-bot-classify.ts

@@ -4,6 +4,7 @@ import { matchesAnyAlias } from '@/channels/engagement'
 import type { ChannelAdapterConfig } from '@/channels/schema'
 import type { InboundAttachment, InboundMessage } from '@/channels/types'
 
+import { hasSlackMessageShareAttachments } from './slack-bot-reference'
 import { slackTsToMillis } from './slack-bot-time'
 
 export type SlackInboundMessageEvent = SlackSocketModeMessageEvent
@@ -62,7 +63,8 @@ export function classifyInbound(
 
   const rawText = event.text ?? ''
   const { text, attachments } = splitInbound(event)
-  if (text === '') return { kind: 'drop', reason: 'empty_text' }
+  const slackAttachments = Array.isArray(event.attachments) ? event.attachments : undefined
+  if (text === '' && !hasSlackMessageShareAttachments(slackAttachments)) return { kind: 'drop', reason: 'empty_text' }
 
   const isDm = event.channel_type === 'im'
   const workspace = isDm ? '@dm' : context.teamId
@@ -92,6 +94,11 @@ export function classifyInbound(
   // found, keeping the cost negligible in mention-heavy channels.
   const aliasMatched = !isBotMention && matchesAnyAlias(rawText, context.selfAliases ?? [])
   const thread = event.thread_ts ?? (!isDm && (isBotMention || aliasMatched) ? event.ts : null)
+  // DMs stay flat (`thread` null), but Slack's typing status still needs a real
+  // message ts; anchor it on the inbound so the indicator renders without
+  // threading the reply. `assistant.threads.setStatus` accepts any live channel
+  // message ts, confirmed against the API.
+  const typingThread = isDm && thread === null ? event.ts : undefined
 
   // A reply is "to the bot" only when the thread parent was authored by the
   // bot. Slack surfaces the parent author via `parent_user_id` on every
@@ -130,6 +137,7 @@ export function classifyInbound(
       workspace,
       chat: event.channel,
       thread,
+      ...(typingThread !== undefined ? { typingThread } : {}),
       text,
       ...(attachments.length > 0 ? { attachments } : {}),
       externalMessageId: event.ts,

package/src/channels/adapters/slack-bot-reference.ts

@@ -0,0 +1,129 @@
+import type { InboundReferenceContext, QuoteAnchorSource } from '@/channels/types'
+
+export type SlackResolvedReference = {
+  authorId: string
+  authorName: string
+  text: string
+}
+
+export type SlackReferenceFetch = (channelId: string, messageTs: string) => Promise<SlackResolvedReference | null>
+
+export type SlackMessagePointer = {
+  channelId: string
+  messageTs: string
+}
+
+export async function enrichSlackReferenceContext(args: {
+  text: string
+  channelId: string
+  threadTs?: string
+  messageTs: string
+  attachments?: readonly unknown[]
+  fetchMessage: SlackReferenceFetch
+  linkLimit?: number
+}): Promise<{ text: string; referenceContext?: InboundReferenceContext }> {
+  const sources: QuoteAnchorSource[] = []
+  let kind: InboundReferenceContext['kind'] = 'link'
+
+  if (args.threadTs !== undefined && args.threadTs !== args.messageTs) {
+    const parent = await fetchSafely(args.fetchMessage, { channelId: args.channelId, messageTs: args.threadTs })
+    if (parent !== null) {
+      sources.push(toSource(parent))
+      kind = 'reply'
+    }
+  }
+
+  for (const source of extractSlackShareSources(args.attachments ?? [])) {
+    sources.push(source)
+    if (kind !== 'reply') kind = 'quote'
+  }
+
+  const links = extractSlackMessageLinks(args.text).slice(0, args.linkLimit ?? 3)
+  const seen = new Set(sources.map((source) => `${source.authorId}\x00${source.text}`))
+  for (const link of links) {
+    const message = await fetchSafely(args.fetchMessage, link)
+    if (message === null) continue
+    const source = toSource(message)
+    const key = `${source.authorId}\x00${source.text}`
+    if (seen.has(key)) continue
+    seen.add(key)
+    sources.push(source)
+  }
+
+  if (sources.length === 0) return { text: args.text }
+  return { text: args.text, referenceContext: { kind, sources } }
+}
+
+export function hasSlackMessageShareAttachments(attachments: readonly unknown[] | undefined): boolean {
+  return extractSlackShareSources(attachments ?? []).length > 0
+}
+
+const SLACK_ARCHIVE_LINK = /https?:\/\/[^\s/]+\.slack\.com\/archives\/([^/\s]+)\/p(\d{10})(\d{6})/g
+
+function extractSlackMessageLinks(text: string): SlackMessagePointer[] {
+  const seen = new Set<string>()
+  const links: SlackMessagePointer[] = []
+  for (const match of text.matchAll(SLACK_ARCHIVE_LINK)) {
+    const channelId = match[1]
+    const seconds = match[2]
+    const micros = match[3]
+    if (channelId === undefined || seconds === undefined || micros === undefined) continue
+    const messageTs = `${seconds}.${micros}`
+    const key = `${channelId}:${messageTs}`
+    if (seen.has(key)) continue
+    seen.add(key)
+    links.push({ channelId, messageTs })
+  }
+  return links
+}
+
+// A stable author id is required because the quote renders as `<@id>`
+// downstream; a name-only source would emit `<@unknown>`, worse than omitting
+// the context. Forwarded message-shares put it under `author_id`, classic
+// shares under `user`/`user_id`. `author_subname` is Slack's display-name
+// fallback on forwarded messages — used for the name only, never the id.
+function extractSlackShareSources(attachments: readonly unknown[]): QuoteAnchorSource[] {
+  const sources: QuoteAnchorSource[] = []
+  for (const attachment of attachments) {
+    const record = recordValue(attachment)
+    if (record === null) continue
+    const text = stringField(record, 'text') ?? stringField(record, 'fallback')
+    if (text === null || text.trim() === '') continue
+    const authorId = stringField(record, 'author_id') ?? stringField(record, 'user') ?? stringField(record, 'user_id')
+    if (authorId === null) continue
+    const authorName = stringField(record, 'author_name') ?? stringField(record, 'author_subname') ?? authorId
+    sources.push({
+      adapter: 'slack-bot',
+      authorId,
+      authorName,
+      text,
+    })
+  }
+  return sources
+}
+
+async function fetchSafely(
+  fetchMessage: SlackReferenceFetch,
+  pointer: SlackMessagePointer,
+): Promise<SlackResolvedReference | null> {
+  try {
+    return await fetchMessage(pointer.channelId, pointer.messageTs)
+  } catch {
+    return null
+  }
+}
+
+function toSource(message: SlackResolvedReference): QuoteAnchorSource {
+  return { adapter: 'slack-bot', authorId: message.authorId, authorName: message.authorName, text: message.text }
+}
+
+function recordValue(value: unknown): Record<string, unknown> | null {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null
+}
+
+function stringField(record: Record<string, unknown>, key: string): string | null {
+  const value = record[key]
+  return typeof value === 'string' && value.length > 0 ? value : null
+}