@threadcrumbs/common 0.0.0-stage → 0.1.1

package/lib/telemetry-fields.mjs

@@ -0,0 +1,245 @@
+export const RECENT_MS = 24 * 60 * 60 * 1000
+
+export const DETAIL_LIMITS = Object.freeze({
+  history: 600,
+  activity: 100,
+  prompts: 50,
+  promptText: 2000,
+  errors: 20,
+  errorText: 500,
+  input: 2000,
+  compactions: 50,
+  subagents: 50,
+  hunks: 5,
+  hunkLines: 60,
+  hunkFiles: 25,
+  lineText: 240,
+})
+
+const TITLE_MAX = 120
+const TARGET_MAX = 160
+const PATH_KEYS = ['file_path', 'filePath', 'notebook_path', 'absolute_path', 'target_file']
+const TEXT_KEYS = ['pattern', 'url', 'query', 'description', 'path']
+const BULKY_KEYS = new Set(['old_string', 'new_string', 'old_str', 'new_str', 'content', 'file_text', 'edits', 'new_source'])
+
+export const number = (v) => (Number.isFinite(Number(v)) ? Number(v) : 0)
+export const text = (v) => (typeof v === 'string' ? v : '')
+
+export function clip(value, max = TARGET_MAX) {
+  const flat = text(value).replace(/\s+/g, ' ').trim()
+  return flat.length > max ? `${flat.slice(0, max - 1).trimEnd()}…` : flat
+}
+
+export function clipBlock(value, max) {
+  const body = text(value).trim()
+  return body.length > max ? `${body.slice(0, max - 1).trimEnd()}…` : body
+}
+
+export function titleFromPrompt(prompt) {
+  const line = text(prompt).split('\n').map((l) => l.trim()).find(Boolean) || ''
+  return clip(line, TITLE_MAX)
+}
+
+const slashes = (value) => value.replace(/\\/g, '/').toLowerCase()
+
+export function relativePath(file, base) {
+  const full = text(file)
+  const root = text(base).replace(/[\\/]+$/, '')
+  const inside = (dir) =>
+    Boolean(dir) && full.length > dir.length + 1 && /[\\/]/.test(full[dir.length]) && slashes(full.slice(0, dir.length)) === slashes(dir)
+  if (inside(root)) return full.slice(root.length + 1)
+  const parent = root.slice(0, Math.max(root.lastIndexOf('/'), root.lastIndexOf('\\')))
+  if (/[\\/]/.test(parent) && inside(parent)) return `..${full[parent.length]}${full.slice(parent.length + 1)}`
+  return full
+}
+
+function commandText(command) {
+  if (!Array.isArray(command)) return text(command)
+  const args = command.map(String)
+  return args.length >= 3 && /^-l?c$/.test(args[1]) ? args[2] : args.join(' ')
+}
+
+export function toolTarget(input, cwd = '', max = TARGET_MAX) {
+  if (typeof input === 'string') return clip(input.split('\n').find((l) => l.trim()) || '', max)
+  if (!input || typeof input !== 'object') return ''
+  for (const key of PATH_KEYS) {
+    if (text(input[key])) return clip(relativePath(input[key], cwd), max)
+  }
+  const command = commandText(input.command ?? input.cmd)
+  if (command.trim()) return clip(command.split('\n').find((l) => l.trim()), max)
+  for (const key of TEXT_KEYS) {
+    if (text(input[key])) return clip(key === 'path' ? relativePath(input[key], cwd) : input[key], max)
+  }
+  return ''
+}
+
+export function toolInput(input) {
+  if (typeof input === 'string') return clipBlock(input, DETAIL_LIMITS.input) || null
+  if (!input || typeof input !== 'object') return null
+  const command = commandText(input.command ?? input.cmd)
+  if (command.trim()) return clipBlock(command, DETAIL_LIMITS.input)
+  const kept = Object.fromEntries(Object.entries(input).filter(([key]) => !BULKY_KEYS.has(key)))
+  return Object.keys(kept).length ? clipBlock(JSON.stringify(kept, null, 2), DETAIL_LIMITS.input) : null
+}
+
+export function toolFile(input, cwd = '') {
+  if (!input || typeof input !== 'object') return { path: null, line: null }
+  for (const key of PATH_KEYS) {
+    if (!text(input[key])) continue
+    const line = Number.isInteger(input.offset) && input.offset > 0 ? input.offset : null
+    return { path: relativePath(input[key], cwd), line }
+  }
+  return { path: null, line: null }
+}
+
+export function keepNewest(list, item, max) {
+  list.push(item)
+  if (list.length > max) list.splice(0, list.length - max)
+  return item
+}
+
+export function patchLines(lines) {
+  let added = 0
+  let removed = 0
+  for (const line of Array.isArray(lines) ? lines : []) {
+    if (typeof line !== 'string') continue
+    if (line.startsWith('+')) added++
+    else if (line.startsWith('-')) removed++
+  }
+  return { added, removed }
+}
+
+export function diffHunk({ line = null, oldLine = null, lines, more = 0 }) {
+  const all = (Array.isArray(lines) ? lines : []).filter((l) => typeof l === 'string')
+  const kept = all.slice(0, DETAIL_LIMITS.hunkLines).map((l) => (l.length > DETAIL_LIMITS.lineText ? `${l.slice(0, DETAIL_LIMITS.lineText - 1)}…` : l))
+  return { line: number(line) || null, oldLine: number(oldLine) || null, lines: kept, cut: all.length - kept.length + more }
+}
+
+export function firstChange(hunk) {
+  if (!hunk?.line) return null
+  return hunk.line + Math.max(0, hunk.lines.findIndex((l) => l.startsWith('+') || l.startsWith('-')))
+}
+
+function trimHunks(files) {
+  let kept = 0
+  for (const entry of [...files.values()].reverse()) {
+    if (entry.hunks?.length && ++kept > DETAIL_LIMITS.hunkFiles) entry.hunks = []
+  }
+}
+
+export function addFileChange(files, file, added, removed, hunks = null) {
+  const entry = files.get(file) || { path: file, added: 0, removed: 0, edits: 0, line: null, hunks: null }
+  entry.added += added
+  entry.removed += removed
+  entry.edits++
+  files.delete(file)
+  files.set(file, entry)
+  if (!hunks?.length) return entry
+  entry.hunks = [...(entry.hunks || []), ...hunks].slice(-DETAIL_LIMITS.hunks)
+  entry.line = firstChange(hunks[0]) ?? entry.line
+  trimHunks(files)
+  return entry
+}
+
+export function fileList(files, cwd) {
+  return [...files.values()]
+    .map((f) => ({ ...f, path: relativePath(f.path, cwd), hunks: f.hunks ? f.hunks.map((h) => ({ ...h })) : f.hunks ?? null }))
+    .sort((a, b) => b.added + b.removed - (a.added + a.removed) || a.path.localeCompare(b.path))
+}
+
+export const emptyActivity = () => ({ calls: [], tools: new Map() })
+
+export function startCall(activity, { id = '', name, target = '', input = null, path = null, line = null, startedAt, running = true }) {
+  if (id && activity.calls.some((c) => c.id === id)) return null
+  const call = keepNewest(
+    activity.calls,
+    { id, name, target, input, path, line, startedAt, endedAt: null, running, error: null, errorText: null },
+    DETAIL_LIMITS.activity,
+  )
+  const tool = activity.tools.get(name) || { name, calls: 0, errors: 0, ms: 0 }
+  tool.calls++
+  activity.tools.set(name, tool)
+  return call
+}
+
+export function endCall(activity, id, endedAt, error, errorText = null) {
+  const call = activity.calls.findLast((c) => c.id === id && c.running)
+  if (!call) return null
+  call.running = false
+  call.endedAt = endedAt ? Math.max(endedAt, call.startedAt) : null
+  call.error = error == null ? null : Boolean(error)
+  call.errorText = call.error ? clipBlock(errorText, DETAIL_LIMITS.errorText) || null : null
+  const tool = activity.tools.get(call.name)
+  if (tool) {
+    if (call.endedAt) tool.ms += call.endedAt - call.startedAt
+    if (call.error) tool.errors++
+  }
+  return call
+}
+
+export function settleCalls(activity) {
+  for (const call of activity.calls) call.running = false
+}
+
+export function activityDetail(activity) {
+  return {
+    activity: activity.calls.map((c) => ({ ...c })),
+    tools: [...activity.tools.values()].map((t) => ({ ...t })).sort((a, b) => b.calls - a.calls || b.ms - a.ms),
+  }
+}
+
+export const planItems = (plan) => (plan || []).map((s) => ({ content: s.content, status: s.status }))
+
+export function planSummary(plan) {
+  if (!plan?.length) return null
+  const current = plan.find((s) => s.status === 'in_progress')
+  return {
+    total: plan.length,
+    done: plan.filter((s) => s.status === 'completed').length,
+    current: current ? current.content : '',
+  }
+}
+
+const planStep = (content, status, id) => ({ content: text(content), status: text(status) || 'pending', id: text(id) })
+const TODO_TOOLS = new Set(['TodoWrite', 'todo_write'])
+
+function mergeTodos(plan, todos) {
+  const next = plan.map((s) => ({ ...s }))
+  for (const t of todos) {
+    const found = t?.id != null ? next.find((s) => s.id && s.id === text(t.id)) : null
+    if (!found) next.push(planStep(t?.content, t?.status, t?.id))
+    else {
+      if (t.content != null) found.content = text(t.content)
+      if (t.status != null) found.status = text(t.status)
+    }
+  }
+  return next
+}
+
+export function nextPlan(plan, tool, input) {
+  if (!input || typeof input !== 'object') return plan
+  if (TODO_TOOLS.has(tool) && Array.isArray(input.todos)) {
+    if (input.merge === true && plan) return mergeTodos(plan, input.todos)
+    return input.todos.map((t) => planStep(t?.content, t?.status, t?.id))
+  }
+  if (/(^|__)ccd_turn__wrap_up$/.test(tool)) return plan && plan.map((s) => (s.status === 'completed' ? s : { ...s, status: 'completed' }))
+  if (!/(^|__)update_plan$/.test(tool)) return plan
+  if (Array.isArray(input.items)) return input.items.map((s) => planStep(s?.content, s?.status))
+  if (Array.isArray(input.plan)) return input.plan.map((s) => planStep(s?.step, s?.status))
+  if (!plan) return plan
+  const next = plan.map((s) => ({ ...s }))
+  if (input.advance) {
+    const current = next.find((s) => s.status === 'in_progress')
+    if (current) current.status = 'completed'
+    const upcoming = next.find((s) => s.status === 'pending')
+    if (upcoming) upcoming.status = 'in_progress'
+  }
+  for (const n of Array.isArray(input.done) ? input.done : []) {
+    if (next[n - 1]) next[n - 1].status = 'completed'
+  }
+  if (Number.isInteger(input.start) && next[input.start - 1]) {
+    for (const s of next) if (s.status === 'in_progress') s.status = 'pending'
+    next[input.start - 1].status = 'in_progress'
+  }
+  return next
+}

package/license/index.mjs

@@ -0,0 +1,102 @@
+const VERSION = 'v1'
+const ALGORITHM = { name: 'Ed25519' }
+const DAY = 86400
+
+export const LICENSE_LIFETIME = 14 * DAY
+export const LICENSE_GRACE = 14 * DAY
+export const LICENSE_RENEWAL = 7 * DAY
+
+export const LICENSE_PUBLIC_KEYS = Object.freeze({
+  '2026-10': 'SyR5jP9LWOFCeOb3piiSLh5CYsgqOfkOgm7a7qkSXQs',
+  'backup-2026-11': 'AAADryrdOxw1mX7b17ZODwqpP7ViKX_eu6_QVuaMBX8',
+})
+
+const encoder = new TextEncoder()
+const decoder = new TextDecoder()
+
+function toBase64Url(bytes) {
+  let binary = ''
+  for (const byte of bytes) binary += String.fromCharCode(byte)
+  return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
+}
+
+function fromBase64Url(text) {
+  if (typeof text !== 'string' || !/^[A-Za-z0-9_-]*$/.test(text)) throw new Error('Not base64url')
+  const binary = atob(text.replace(/-/g, '+').replace(/_/g, '/') + '='.repeat((4 - (text.length % 4)) % 4))
+  return Uint8Array.from(binary, (char) => char.charCodeAt(0))
+}
+
+const seconds = (value) => typeof value === 'number' && Number.isFinite(value)
+
+function wellFormed(claims) {
+  if (!claims || typeof claims !== 'object') return false
+  if (typeof claims.kid !== 'string' || typeof claims.sub !== 'string' || typeof claims.dev !== 'string') return false
+  if (!seconds(claims.iat) || !seconds(claims.exp) || claims.exp <= claims.iat) return false
+  if (!claims.ent || typeof claims.ent !== 'object' || Array.isArray(claims.ent)) return false
+  return Object.values(claims.ent).every(seconds)
+}
+
+export async function createLicenseKeys(kid) {
+  const pair = await crypto.subtle.generateKey(ALGORITHM, true, ['sign', 'verify'])
+  const publicKey = toBase64Url(new Uint8Array(await crypto.subtle.exportKey('raw', pair.publicKey)))
+  const { alg, ...jwk } = await crypto.subtle.exportKey('jwk', pair.privateKey)
+  return { kid, publicKey, privateKey: { ...jwk, kid } }
+}
+
+export function publicKeyOf(privateKey) {
+  if (privateKey?.kty !== 'OKP' || privateKey.crv !== 'Ed25519' || typeof privateKey.x !== 'string') throw new Error('Not an Ed25519 key')
+  return privateKey.x
+}
+
+export function licenseClaims({ customer, device, entitlements, now = Date.now() / 1000 }) {
+  const iat = Math.floor(now)
+  return { sub: customer, dev: device, iat, exp: iat + LICENSE_LIFETIME, ent: { ...entitlements } }
+}
+
+export async function signLicense(claims, privateKey) {
+  const body = { ...claims, kid: privateKey.kid }
+  if (!wellFormed(body)) throw new Error('A license needs sub, dev, iat, exp after iat, and paid-through times in ent')
+  const { alg, ...jwk } = privateKey
+  const key = await crypto.subtle.importKey('jwk', jwk, ALGORITHM, false, ['sign'])
+  const signed = `${VERSION}.${toBase64Url(encoder.encode(JSON.stringify(body)))}`
+  const signature = new Uint8Array(await crypto.subtle.sign(ALGORITHM, key, encoder.encode(signed)))
+  return `${signed}.${toBase64Url(signature)}`
+}
+
+export async function verifyLicense(token, { keys = {}, device } = {}) {
+  const parts = typeof token === 'string' ? token.trim().split('.') : []
+  if (parts.length !== 3) return { ok: false, reason: 'malformed' }
+  const [version, body, signature] = parts
+  if (version !== VERSION) return { ok: false, reason: 'version' }
+  let claims
+  let signatureBytes
+  try {
+    claims = JSON.parse(decoder.decode(fromBase64Url(body)))
+    signatureBytes = fromBase64Url(signature)
+  } catch {
+    return { ok: false, reason: 'malformed' }
+  }
+  const publicKey = typeof claims?.kid === 'string' && Object.hasOwn(keys, claims.kid) ? keys[claims.kid] : undefined
+  if (typeof publicKey !== 'string') return { ok: false, reason: 'unknown key' }
+  const key = await crypto.subtle.importKey('raw', fromBase64Url(publicKey), ALGORITHM, false, ['verify'])
+  if (!(await crypto.subtle.verify(ALGORITHM, key, signatureBytes, encoder.encode(`${version}.${body}`)))) {
+    return { ok: false, reason: 'signature' }
+  }
+  if (!wellFormed(claims)) return { ok: false, reason: 'malformed' }
+  if (device !== undefined && claims.dev !== device) return { ok: false, reason: 'device' }
+  return { ok: true, license: claims }
+}
+
+export function paidThrough(license, entitlement, now = Date.now() / 1000, grace = LICENSE_GRACE) {
+  const through = license?.ent?.[entitlement]
+  if (!seconds(through)) return 0
+  return now <= license.exp + grace ? through : Math.min(through, license.exp)
+}
+
+export function unlocks(license, entitlement, releasedAt, now = Date.now() / 1000, grace = LICENSE_GRACE) {
+  return seconds(releasedAt) && releasedAt <= paidThrough(license, entitlement, now, grace)
+}
+
+export function renewalDue(license, now = Date.now() / 1000) {
+  return now >= license.iat + LICENSE_RENEWAL
+}

package/license/store.mjs

@@ -0,0 +1,155 @@
+import { randomBytes } from 'node:crypto'
+import fsp from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { LICENSE_PUBLIC_KEYS, verifyLicense } from './index.mjs'
+
+const FILE = 'license.json'
+const DEVICE = /^[A-Za-z0-9_-]{8,100}$/
+const SEEN_STEP = 3600
+const READ_TRIES = 5
+const RENAME_TRIES = 10
+const PAUSE_MS = 20
+const CLOUD_URL = 'https://threadcrumbs.io/api'
+const LOCAL_CLOUD_URL = 'http://localhost:8787/api'
+
+const pause = () => new Promise((resolve) => setTimeout(resolve, PAUSE_MS))
+const isDevice = (value) => typeof value === 'string' && DEVICE.test(value)
+const finite = (value) => (typeof value === 'number' && Number.isFinite(value) ? value : 0)
+
+export function threadcrumbsDataDir({ platform = process.platform, env = process.env, home = os.homedir() } = {}) {
+  if (env.THREADCRUMBS_DATA_DIR) return env.THREADCRUMBS_DATA_DIR
+  if (platform === 'win32') {
+    return path.win32.join(env.APPDATA || path.win32.join(home, 'AppData', 'Roaming'), 'Threadcrumbs')
+  }
+  if (platform === 'darwin') return path.posix.join(home, 'Library', 'Application Support', 'Threadcrumbs')
+  const xdg = env.XDG_DATA_HOME && path.posix.isAbsolute(env.XDG_DATA_HOME) ? env.XDG_DATA_HOME : ''
+  return path.posix.join(xdg || path.posix.join(home, '.local', 'share'), 'threadcrumbs')
+}
+
+export function trustedKeys({ env = process.env, development = false } = {}) {
+  const extra = development ? env.THREADCRUMBS_LICENSE_KEYS : ''
+  if (!extra) return { ...LICENSE_PUBLIC_KEYS }
+  let parsed
+  try {
+    parsed = JSON.parse(extra)
+  } catch {
+    throw new Error('THREADCRUMBS_LICENSE_KEYS must be JSON: { "<kid>": "<public key>" }')
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed) || !Object.values(parsed).every((k) => typeof k === 'string')) {
+    throw new Error('THREADCRUMBS_LICENSE_KEYS must map each key ID to a public key')
+  }
+  return { ...LICENSE_PUBLIC_KEYS, ...parsed }
+}
+
+export function cloudUrl({ env = process.env, development = false } = {}) {
+  return (env.THREADCRUMBS_CLOUD_URL || (development ? LOCAL_CLOUD_URL : CLOUD_URL)).replace(/\/+$/, '')
+}
+
+async function check(token, keys, device) {
+  try {
+    return await verifyLicense(token, { keys, device })
+  } catch {
+    return { ok: false, reason: 'malformed' }
+  }
+}
+
+export function licenseStore({ dir = threadcrumbsDataDir(), keys = LICENSE_PUBLIC_KEYS, now = () => Date.now() / 1000 } = {}) {
+  const file = path.join(dir, FILE)
+
+  async function read() {
+    let text
+    try {
+      text = await fsp.readFile(file, 'utf8')
+    } catch (err) {
+      if (err.code === 'ENOENT') return null
+      throw err
+    }
+    try {
+      const data = JSON.parse(text)
+      return data && typeof data === 'object' && !Array.isArray(data) ? data : {}
+    } catch {
+      return {}
+    }
+  }
+
+  const serialize = (data) => `${JSON.stringify(data, null, 2)}\n`
+
+  async function replace(data) {
+    await fsp.mkdir(dir, { recursive: true })
+    const temp = `${file}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`
+    try {
+      await fsp.writeFile(temp, serialize(data), { mode: 0o600 })
+      for (let attempt = 1; ; attempt++) {
+        try {
+          return await fsp.rename(temp, file)
+        } catch (err) {
+          if (attempt >= RENAME_TRIES || !['EPERM', 'EACCES', 'EBUSY'].includes(err.code)) throw err
+          await pause()
+        }
+      }
+    } catch (err) {
+      await fsp.rm(temp, { force: true })
+      throw err
+    }
+  }
+
+  async function device() {
+    for (let attempt = 0; attempt < READ_TRIES; attempt++) {
+      const data = await read()
+      if (isDevice(data?.device)) return data.device
+      if (data === null) {
+        await fsp.mkdir(dir, { recursive: true })
+        try {
+          await fsp.writeFile(file, serialize({ device: randomBytes(18).toString('base64url'), license: null, seen: 0 }), { flag: 'wx', mode: 0o600 })
+        } catch (err) {
+          if (err.code !== 'EEXIST') throw err
+        }
+        continue
+      }
+      await pause()
+    }
+    await replace({ device: randomBytes(18).toString('base64url'), license: null, seen: 0 })
+    const data = await read()
+    if (!isDevice(data?.device)) throw new Error(`Can't read or replace ${file}`)
+    return data.device
+  }
+
+  async function update(change) {
+    const data = (await read()) ?? {}
+    await replace({ ...data, ...change, device: data.device })
+  }
+
+  async function current() {
+    const clock = now()
+    if ((await read()) === null) return { device: null, token: null, license: null, at: clock }
+    const dev = await device()
+    const data = (await read()) ?? {}
+    const seen = finite(data.seen)
+    if (typeof data.license !== 'string') return { device: dev, token: null, license: null, at: Math.max(clock, seen) }
+    const checked = await check(data.license, keys, dev)
+    if (!checked.ok) return { device: dev, token: null, license: null, reason: checked.reason, at: Math.max(clock, seen) }
+    if (clock > seen + SEEN_STEP) await update({ seen: clock }).catch(() => {})
+    return { device: dev, token: data.license, license: checked.license, at: Math.max(clock, seen, checked.license.iat) }
+  }
+
+  async function save(token) {
+    const dev = await device()
+    const checked = await check(token, keys, dev)
+    if (!checked.ok) return checked
+    const data = (await read()) ?? {}
+    const stored = typeof data.license === 'string' ? await check(data.license, keys, dev) : null
+    if (stored?.ok && stored.license.iat > checked.license.iat) {
+      return { ok: true, license: stored.license, at: Math.max(now(), finite(data.seen), stored.license.iat) }
+    }
+    await update({ license: token, seen: checked.license.iat })
+    return { ok: true, license: checked.license, at: Math.max(now(), checked.license.iat) }
+  }
+
+  async function clear() {
+    await device()
+    await update({ license: null })
+  }
+
+  return { file, device, current, save, clear }
+}

package/orgs/index.mjs

@@ -0,0 +1,157 @@
+import fsp from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+
+const REMEMBER_MS = 60 * 1000
+const ROOT_LEVELS = 6
+const CODE_HOSTS = new Set(['github.com', 'gitlab.com', 'bitbucket.org', 'codeberg.org', 'gitea.com'])
+const TOP_LEVEL_DOMAINS = new Set(['com', 'org', 'net', 'io', 'dev', 'app', 'co', 'ai', 'me', 'xyz', 'edu', 'gov', 'info', 'biz', 'tech', 'cloud', 'us', 'uk', 'de', 'fr', 'nl', 'ca', 'au', 'jp', 'ch', 'se', 'no', 'fi', 'es', 'it', 'be', 'at', 'dk', 'pl', 'br', 'in'])
+const NAME = /^[a-z0-9][\w.-]*$/i
+
+const clean = (value) => {
+  const name = String(value || '').trim().replace(/^[@~]/, '').toLowerCase()
+  return NAME.test(name) ? name : null
+}
+
+const parseJson = (text) => {
+  try {
+    return JSON.parse(text)
+  } catch {
+    try {
+      return JSON.parse(text.replace(/\/\*[\s\S]*?\*\/|^\s*\/\/.*$/gm, '').replace(/,(\s*[}\]])/g, '$1'))
+    } catch {
+      return null
+    }
+  }
+}
+
+export const scopeOf = (name) => clean(/^@([^/\s]+)\/[^/\s]+$/.exec(String(name || ''))?.[1])
+
+export const vendorOf = (name) => clean(/^([^/@\s]+)\/[^/\s]+$/.exec(String(name || ''))?.[1])
+
+export function ownerOfModule(modulePath) {
+  const [host, owner, repo] = String(modulePath || '').split('/')
+  return CODE_HOSTS.has(host?.toLowerCase()) && repo ? clean(owner) : null
+}
+
+export function organizationOfGroup(group) {
+  const labels = String(group || '').trim().toLowerCase().split('.').filter(Boolean)
+  if (labels.length >= 2 && TOP_LEVEL_DOMAINS.has(labels[0])) return clean(labels[1])
+  return labels.length ? clean(labels[0]) : null
+}
+
+export const prefixOf = (id) => clean(/^([^.\s]+)\.[^\s]+$/.exec(String(id || '').trim())?.[1])
+
+const tag = (xml, name) => new RegExp(`<${name}>\\s*([^<]+?)\\s*</${name}>`).exec(xml)?.[1]
+
+const MANIFESTS = [
+  ['package.json', (text) => scopeOf(parseJson(text)?.name)],
+  ['jsr.json', (text) => scopeOf(parseJson(text)?.name)],
+  ['deno.json', (text) => scopeOf(parseJson(text)?.name)],
+  ['deno.jsonc', (text) => scopeOf(parseJson(text)?.name)],
+  ['composer.json', (text) => vendorOf(parseJson(text)?.name)],
+  ['go.mod', (text) => ownerOfModule(/^\s*module\s+(\S+)/m.exec(text)?.[1])],
+  [
+    'pom.xml',
+    (text) => {
+      const own = text.replace(/<parent>[\s\S]*?<\/parent>/, '').replace(/<(dependencies|dependencyManagement|build|profiles|plugins)>[\s\S]*$/, '')
+      return organizationOfGroup(tag(own, 'groupId') || tag(text, 'groupId'))
+    },
+  ],
+  ['build.gradle', (text) => organizationOfGroup(/^\s*group\s*=?\s*['"]([^'"]+)['"]/m.exec(text)?.[1])],
+  ['build.gradle.kts', (text) => organizationOfGroup(/^\s*group\s*=\s*"([^"]+)"/m.exec(text)?.[1])],
+  ['galaxy.yml', (text) => clean(/^namespace:\s*['"]?([\w-]+)/m.exec(text)?.[1])],
+]
+
+export function remoteOwner(gitConfig) {
+  const section = /\[remote "origin"\]([\s\S]*?)(?=\n\s*\[|$)/.exec(String(gitConfig || ''))?.[1] || ''
+  const url = /^\s*url\s*=\s*(\S+)/m.exec(section)?.[1]
+  if (!url) return null
+  const match = /^(?:[a-z+]+:\/\/)?(?:[^@/]+@)?([^/:]+)[:/]+([^/]+)\/[^/]+?(?:\.git)?\/?$/i.exec(url)
+  return match && CODE_HOSTS.has(match[1].toLowerCase()) ? clean(match[2]) : null
+}
+
+const readText = (file) => fsp.readFile(file, 'utf8').catch(() => null)
+
+const folderKey = (dir) => {
+  const bare = /^\\\\\?\\[A-Za-z]:[\\/]/.test(dir) ? dir.slice(4) : dir
+  return /^[A-Za-z]:[\\/]/.test(bare) ? bare[0].toLowerCase() + bare.slice(1) : bare
+}
+
+async function gitConfigOf(dir, read) {
+  const own = await read(path.join(dir, '.git', 'config'))
+  if (own != null) return own
+  const pointer = /^gitdir:\s*(.+)$/m.exec((await read(path.join(dir, '.git'))) || '')?.[1]?.trim()
+  if (!pointer) return null
+  const gitdir = path.resolve(dir, pointer)
+  return (await read(path.join(gitdir, 'config'))) ?? read(path.join(gitdir, '..', '..', 'config'))
+}
+
+async function manifestIn(dir, read, list) {
+  for (const [file, parse] of MANIFESTS) {
+    const text = await read(path.join(dir, file))
+    const found = text != null && parse(text)
+    if (found) return found
+  }
+  for (const file of (await list(dir)).filter((name) => /\.(csproj|nuspec)$/i.test(name))) {
+    const text = await read(path.join(dir, file))
+    const found = text != null && prefixOf(tag(text, 'PackageId') || tag(text, 'id'))
+    if (found) return found
+  }
+  return null
+}
+
+const sameFolder = (a, b) => (process.platform === 'win32' ? a.toLowerCase() === b.toLowerCase() : a === b)
+
+export async function signalsOf(dir, { read = readText, list = (d) => fsp.readdir(d).catch(() => []), home = os.homedir() } = {}) {
+  if (!(await list(dir)).length) return { manifest: null, remote: null, root: dir }
+  const top = home ? path.resolve(home) : null
+  let at = dir
+  for (let level = 0; level <= ROOT_LEVELS; level++) {
+    const config = await gitConfigOf(at, read)
+    if (config != null) return { manifest: await manifestIn(at, read, list), remote: remoteOwner(config), root: at }
+    const parent = path.dirname(at)
+    if (parent === at || (top && sameFolder(path.resolve(parent), top))) break
+    at = parent
+  }
+  return { manifest: await manifestIn(dir, read, list), remote: null, root: dir }
+}
+
+export function organizationsFor(signals) {
+  const named = new Map()
+  const counted = new Set()
+  for (const [dir, { manifest, root }] of signals) {
+    const repo = `${root ?? dir}\n${manifest}`
+    if (!manifest || counted.has(repo)) continue
+    counted.add(repo)
+    named.set(manifest, (named.get(manifest) ?? 0) + 1)
+  }
+  const support = (org) => named.get(org) ?? 0
+  const orgs = new Map()
+  for (const [dir, { manifest, remote }] of signals) {
+    const org = manifest && remote && support(remote) > support(manifest) ? remote : manifest || (support(remote) ? remote : null)
+    if (org) orgs.set(dir, org)
+  }
+  return orgs
+}
+
+export function organizationReader({ signals = signalsOf, now = Date.now } = {}) {
+  const cache = new Map()
+  const signalsFor = async (dir) => {
+    const hit = cache.get(dir)
+    if (hit && now() - hit.at < REMEMBER_MS) return hit.value
+    const value = await signals(dir)
+    cache.set(dir, { at: now(), value })
+    return value
+  }
+  return async function withOrganizations(threads) {
+    const keys = new Map(threads.map((t) => t.projectPath).filter((dir) => dir && path.isAbsolute(dir)).map((dir) => [dir, folderKey(dir)]))
+    const dirs = [...new Set(keys.values())]
+    const found = new Map(await Promise.all(dirs.map(async (dir) => [dir, await signalsFor(dir)])))
+    const orgs = organizationsFor(found)
+    return threads.map((t) => {
+      const org = orgs.get(keys.get(t.projectPath))
+      return org ? { ...t, org } : t
+    })
+  }
+}