@tduyng/pi-cursor 0.0.0-stage → 0.0.2

package/src/models.ts

@@ -0,0 +1,198 @@
+import type { ModelListItem, ModelParameterDefinition, ModelParameterValue } from '@cursor/sdk'
+import type { ModelThinkingLevel, ThinkingLevelMap } from '@earendil-works/pi-ai'
+
+export type PiModelEntry = {
+    id: string
+    name: string
+    reasoning: boolean
+    thinkingLevelMap?: ThinkingLevelMap
+    input: ('text' | 'image')[]
+    cost: { input: number; output: number; cacheRead: number; cacheWrite: number }
+    contextWindow: number
+    maxTokens: number
+}
+
+export type ModelSelection = { id: string; params?: ModelParameterValue[] }
+
+type ThinkingParams = { boolean?: ModelParameterDefinition; levels?: ModelParameterDefinition }
+
+const LEVELS: ModelThinkingLevel[] = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']
+export type ModelInfo = Pick<ModelListItem, 'id' | 'displayName' | 'parameters' | 'variants'>
+
+const catalog = new Map<string, ModelInfo>()
+
+const FALLBACK_MODELS: PiModelEntry[] = [
+    entry('auto-smart', 'Auto'),
+    entry('claude-opus-4-8', 'Claude Opus 4.8', 300_000),
+    entry('claude-sonnet-5-5', 'Claude Sonnet 5.5'),
+    entry('gpt-5.5', 'GPT-5.5', 272_000),
+    entry('grok-4.6', 'Grok 4.6', 256_000),
+    entry('composer-2.5', 'Composer 2.5'),
+    entry('gemini-3.7-flash', 'Gemini 3.7 Flash')
+]
+
+function entry(id: string, name: string, contextWindow = 200_000): PiModelEntry {
+    return {
+        id,
+        name,
+        reasoning: false,
+        input: ['text', 'image'],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow,
+        maxTokens: 32_768
+    }
+}
+
+export function rememberModels(items: ModelInfo[]): void {
+    catalog.clear()
+    for (const item of items) catalog.set(item.id, item)
+}
+
+export function fallbackModels(): PiModelEntry[] {
+    return FALLBACK_MODELS.map((model) => ({ ...model }))
+}
+
+export function toPiModels(items: ModelInfo[]): PiModelEntry[] {
+    const entries: PiModelEntry[] = []
+    for (const item of items) {
+        const contexts = contextValues(item)
+        entries.push(toPiModel(item, undefined, contexts[0]))
+        for (const context of contexts.slice(1)) entries.push(toPiModel(item, context, context))
+    }
+    return entries
+}
+
+export type ModelIdParts = { base: string; context?: string }
+
+export function parseModelId(id: string): ModelIdParts {
+    const match = /^(.+)@(\d+[km])$/.exec(id)
+    if (!match?.[1] || !match[2]) return { base: id }
+    return { base: match[1], context: match[2] }
+}
+
+function contextValues(item: ModelInfo): string[] {
+    const values = item.parameters?.find((candidate) => candidate.id === 'context')?.values.map((value) => value.value)
+    if (!values) return []
+    return values.toSorted((left, right) => contextSize(left) - contextSize(right))
+}
+
+function contextSize(context: string): number {
+    const match = /^(\d+)([km])$/.exec(context)
+    if (!match?.[1] || !match[2]) return Number.MAX_SAFE_INTEGER
+    const size = Number(match[1])
+    return match[2] === 'm' ? size * 1_000_000 : size * 1_000
+}
+
+export function contextWindowOf(id: string): number {
+    const { base, context } = parseModelId(id)
+    if (context) return contextSize(context)
+    return contextWindowFor(base)
+}
+
+function toPiModel(item: ModelInfo, suffix: string | undefined, window: string | undefined): PiModelEntry {
+    const params = thinkingParams(item)
+    const id = suffix ? `${item.id}@${suffix}` : item.id
+    const displayName = item.displayName || item.id
+    const name = suffix ? `${displayName} ${suffix.toUpperCase()}` : displayName
+    const model = entry(id, name, window ? contextSize(window) : contextWindowFor(item.id))
+    if (params) {
+        model.reasoning = true
+        model.thinkingLevelMap = thinkingLevelMap(params)
+    }
+    return model
+}
+
+function thinkingParams(item: ModelInfo): ThinkingParams | undefined {
+    const boolean = item.parameters?.find(
+        (candidate) =>
+            candidate.id === 'thinking' &&
+            candidate.values.length > 0 &&
+            candidate.values.every((value) => value.value === 'true' || value.value === 'false')
+    )
+    const levels =
+        item.parameters?.find((candidate) => candidate.id === 'effort' && candidate.values.length > 0) ??
+        item.parameters?.find((candidate) => candidate.id === 'reasoning' && candidate.values.length > 0)
+    if (!boolean && !levels) return undefined
+    return { boolean, levels }
+}
+
+function thinkingLevelMap(params: ThinkingParams): ThinkingLevelMap | undefined {
+    const map: ThinkingLevelMap = {}
+    let any = false
+    for (const level of LEVELS) {
+        let value: string | undefined
+        if (level === 'off') value = params.boolean ? 'false' : mapLevel(params.levels, level)
+        else if (params.levels) value = mapLevel(params.levels, level)
+        else value = params.boolean ? 'true' : undefined
+        map[level] = value ?? null
+        if (value) any = true
+    }
+    return any ? map : undefined
+}
+
+function mapLevel(param: ModelParameterDefinition | undefined, level: ModelThinkingLevel): string | undefined {
+    const values = param?.values.map((value) => value.value) ?? []
+    if (level === 'off') return values.find((value) => value === 'none' || value === 'false' || value === 'off')
+    if (level === 'minimal') {
+        return values.find((value) => value === 'minimal') ?? values.find((value) => value === 'low')
+    }
+    if (level === 'low') return values.find((value) => value === 'low')
+    if (level === 'medium') return values.find((value) => value === 'medium')
+    if (level === 'high') return values.find((value) => value === 'high')
+    if (level === 'xhigh') {
+        return values.find((value) => value === 'xhigh') ?? values.find((value) => value === 'extra-high')
+    }
+    return (
+        values.find((value) => value === 'max') ??
+        values.find((value) => value === 'xhigh') ??
+        values.find((value) => value === 'extra-high')
+    )
+}
+
+export function selectionFor(id: string, level: ModelThinkingLevel | undefined, fast = false): ModelSelection {
+    const { base, context } = parseModelId(id)
+    const item = catalog.get(base)
+    if (!item) return { id: base }
+    const variant = item.variants?.find((candidate) => candidate.isDefault) ?? item.variants?.[0]
+    const ordered = variant?.params.map((param) => param.id) ?? []
+    const values = new Map<string, string>()
+    for (const param of variant?.params ?? []) values.set(param.id, param.value)
+    const chosenContext = context ?? contextValues(item)[0]
+    if (chosenContext) {
+        values.set('context', chosenContext)
+        if (!ordered.includes('context')) ordered.push('context')
+    }
+    if (fast && item.parameters?.some((candidate) => candidate.id === 'fast')) {
+        values.set('fast', 'true')
+        if (!ordered.includes('fast')) ordered.push('fast')
+    }
+    const params = thinkingParams(item)
+    if (params && level) {
+        if (params.boolean) {
+            values.set(params.boolean.id, level === 'off' ? 'false' : 'true')
+            if (!ordered.includes(params.boolean.id)) ordered.push(params.boolean.id)
+        }
+        if (params.levels) {
+            const value = mapLevel(params.levels, level)
+            if (value) values.set(params.levels.id, value)
+            if (!ordered.includes(params.levels.id)) ordered.push(params.levels.id)
+        }
+    }
+    const result: ModelParameterValue[] = []
+    for (const key of ordered) {
+        const value = values.get(key)
+        if (value !== undefined) result.push({ id: key, value })
+    }
+    return result.length > 0 ? { id: base, params: result } : { id: base }
+}
+
+export function contextWindowFor(id: string): number {
+    if (id.startsWith('gpt-5')) return 272_000
+    if (id.startsWith('grok')) return 256_000
+    return 200_000
+}
+
+export function modelName(id: string): string {
+    const { base } = parseModelId(id)
+    return catalog.get(base)?.displayName ?? FALLBACK_MODELS.find((model) => model.id === base)?.name ?? id
+}

package/src/resume.ts

@@ -0,0 +1,81 @@
+import { readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { getAgentDir } from '@earendil-works/pi-coding-agent'
+import { Validator, type Infer } from 'ata-validator'
+import { t } from 'ata-validator/t'
+
+import type { SessionKey } from './session.js'
+import type { Transcript, TurnMessage } from './transcript.js'
+
+const ResumeRecord = t.object({
+    sessionId: t.string(),
+    agentId: t.string(),
+    cwd: t.string(),
+    toolsHash: t.string(),
+    count: t.number(),
+    chain: t.string(),
+    at: t.number()
+})
+
+const ResumeLedger = t.object({ records: t.array(ResumeRecord) })
+
+const isLedger = new Validator(ResumeLedger).isValidObject
+
+export type AgentRecord = Infer<typeof ResumeRecord>
+
+const KEEP = 20
+
+function ledgerPath(): string {
+    return join(getAgentDir(), 'pi-cursor-agents.json')
+}
+
+function readLedger(): AgentRecord[] {
+    try {
+        const parsed: unknown = JSON.parse(readFileSync(ledgerPath(), 'utf8'))
+        return isLedger(parsed) ? parsed.records : []
+    } catch {
+        return []
+    }
+}
+
+export function dropAllRecords(): void {
+    rmSync(ledgerPath(), { force: true })
+}
+
+export function readRecord(sessionId: string): AgentRecord | undefined {
+    return readLedger().findLast((record) => record.sessionId === sessionId)
+}
+
+export function writeRecord(record: AgentRecord): void {
+    const records = readLedger().filter((candidate) => candidate.sessionId !== record.sessionId)
+    records.push(record)
+    const path = ledgerPath()
+    const temp = `${path}.${process.pid}.tmp`
+    const kept = records.toSorted((left, right) => left.at - right.at).slice(-KEEP)
+    writeFileSync(temp, JSON.stringify({ records: kept }), { mode: 0o600 })
+    renameSync(temp, path)
+}
+
+export function dropRecord(sessionId: string): void {
+    const records = readLedger().filter((candidate) => candidate.sessionId !== sessionId)
+    const path = ledgerPath()
+    const temp = `${path}.${process.pid}.tmp`
+    writeFileSync(temp, JSON.stringify({ records }), { mode: 0o600 })
+    renameSync(temp, path)
+}
+
+export function resumeTail(
+    record: AgentRecord,
+    transcript: Transcript,
+    key: SessionKey
+): TurnMessage[] | undefined {
+    if (record.cwd !== key.cwd) return undefined
+    if (record.toolsHash !== key.toolsHash) return undefined
+    if (record.count >= transcript.chain.length) return undefined
+    if (transcript.chain[record.count] !== record.chain) return undefined
+    const tail = transcript.messages.slice(record.count)
+    if (tail.some((message) => message.role === 'assistant' || message.role === 'toolResult')) return undefined
+    if (!tail.some((message) => message.role === 'user')) return undefined
+    return tail
+}

package/src/sdk.ts

@@ -0,0 +1,14 @@
+type CursorSdk = typeof import('@cursor/sdk')
+
+let loading: Promise<CursorSdk> | undefined
+
+export function cursorSdk(): Promise<CursorSdk> {
+    loading ??= import('@cursor/sdk')
+    return loading
+}
+
+export function cursorApiKey(): string | undefined {
+    const value = process.env['CURSOR_API_KEY']
+    const trimmed = value?.trim()
+    return trimmed && trimmed.length > 0 ? trimmed : undefined
+}