opencode-vim 0.0.2

package/src/modules/snippets/search.ts

@@ -0,0 +1,118 @@
+import type { SkillInfo, SnippetInfo } from "./types"
+
+export type HighlightPart = {
+    text: string
+    match: boolean
+}
+
+function normalizeSearchText(input: string) {
+    return input.toLowerCase().replace(/[^a-z0-9]/g, "")
+}
+
+function scoreText(input: string, query: string) {
+    const raw = input.toLowerCase()
+    const compact = normalizeSearchText(input)
+    const needle = query.toLowerCase().trim()
+    const compactNeedle = normalizeSearchText(query)
+
+    if (raw === needle) return 0
+    if (compactNeedle && compact === compactNeedle) return 1
+    if (raw.startsWith(needle)) return 2
+    if (compactNeedle && compact.startsWith(compactNeedle)) return 3
+    if (raw.includes(needle)) return 4
+    if (compactNeedle && compact.includes(compactNeedle)) return 5
+    return Number.POSITIVE_INFINITY
+}
+
+function snippetDescription(snippet: SnippetInfo) {
+    return (snippet.description || snippet.content).replace(/\s+/g, " ").trim()
+}
+
+function scoreSnippet(snippet: SnippetInfo, query: string) {
+    if (!query) return 0
+
+    const nameScore = Math.min(scoreText(snippet.name, query), ...snippet.aliases.map((alias) => scoreText(alias, query)))
+    if (Number.isFinite(nameScore)) return nameScore
+
+    const description = (snippet.description || "").replace(/\s+/g, " ").trim().toLowerCase()
+    const lowerQuery = query.toLowerCase()
+    if (description.startsWith(lowerQuery)) return 6
+    if (description.includes(lowerQuery)) return 7
+    return Number.POSITIVE_INFINITY
+}
+
+function sourceRank(snippet: SnippetInfo) {
+    return snippet.source === "project" ? 0 : 1
+}
+
+export function filterSnippets(snippets: SnippetInfo[], query: string) {
+    const needle = query.trim()
+    return snippets
+        .map((snippet) => ({ snippet, score: scoreSnippet(snippet, needle) }))
+        .filter((entry) => Number.isFinite(entry.score))
+        .sort((left, right) => left.score - right.score || sourceRank(left.snippet) - sourceRank(right.snippet) || left.snippet.name.localeCompare(right.snippet.name))
+        .map((entry) => entry.snippet)
+}
+
+export function matchedAliases(snippet: SnippetInfo, query: string) {
+    const needle = query.trim()
+    if (!needle) return []
+    return snippet.aliases.filter((alias) => Number.isFinite(scoreText(alias, needle)))
+}
+
+export function describeSnippet(snippet: SnippetInfo) {
+    return snippetDescription(snippet)
+}
+
+export function highlightMatches(input: string, query: string): HighlightPart[] {
+    const needle = query.trim().toLowerCase()
+    if (!needle) return [{ text: input, match: false }]
+
+    const lower = input.toLowerCase()
+    const parts: HighlightPart[] = []
+    let cursor = 0
+
+    while (cursor < input.length) {
+        const index = lower.indexOf(needle, cursor)
+        if (index < 0) break
+        if (index > cursor) parts.push({ text: input.slice(cursor, index), match: false })
+        parts.push({ text: input.slice(index, index + needle.length), match: true })
+        cursor = index + needle.length
+    }
+
+    if (parts.length === 0) return [{ text: input, match: false }]
+    if (cursor < input.length) parts.push({ text: input.slice(cursor), match: false })
+    return parts
+}
+
+function skillTag(skill: SkillInfo) {
+    return `skill(${skill.name})`
+}
+
+function scoreSkill(skill: SkillInfo, query: string) {
+    if (!query) return 0
+    const nameScore = Math.min(scoreText(skill.name, query), scoreText(skillTag(skill), query))
+    if (Number.isFinite(nameScore)) return nameScore
+    const description = (skill.description || "").replace(/\s+/g, " ").trim().toLowerCase()
+    const lowerQuery = query.toLowerCase()
+    if (description.startsWith(lowerQuery)) return 6
+    if (description.includes(lowerQuery)) return 7
+    return Number.POSITIVE_INFINITY
+}
+
+function skillSourceRank(skill: SkillInfo) {
+    return skill.source === "project" ? 0 : 1
+}
+
+export function filterSkills(skills: SkillInfo[], query: string) {
+    const needle = query.trim()
+    return skills
+        .map((skill) => ({ skill, score: scoreSkill(skill, needle) }))
+        .filter((entry) => Number.isFinite(entry.score))
+        .sort((left, right) => left.score - right.score || skillSourceRank(left.skill) - skillSourceRank(right.skill) || left.skill.name.localeCompare(right.skill.name))
+        .map((entry) => entry.skill)
+}
+
+export function describeSkill(skill: SkillInfo) {
+    return (skill.description || skill.content).replace(/\s+/g, " ").trim()
+}

package/src/modules/snippets/skill-loader.ts

@@ -0,0 +1,81 @@
+import { dirname, join, parse } from "node:path"
+import type { SkillInfo, SnippetSource } from "./types"
+import { parseFrontmatter } from "./loader"
+
+const SKILL_FILE = "SKILL.md"
+
+export async function loadSkills(projectDir?: string) {
+    const registry = new Map<string, SkillInfo>()
+    const home = process.env.HOME
+
+    if (home) {
+        await loadSkillDir(registry, join(home, ".config/opencode/skill"), "global")
+        await loadSkillDir(registry, join(home, ".config/opencode/skills"), "global")
+        await loadSkillDir(registry, join(home, ".claude/skills"), "global")
+        await loadSkillDir(registry, join(home, ".agents/skills"), "global")
+    }
+
+    for (const root of await projectRoots(projectDir)) {
+        await loadSkillDir(registry, join(root, ".opencode/skill"), "project")
+        await loadSkillDir(registry, join(root, ".opencode/skills"), "project")
+        await loadSkillDir(registry, join(root, ".claude/skills"), "project")
+        await loadSkillDir(registry, join(root, ".agents/skills"), "project")
+    }
+
+    return [...registry.values()].sort((left, right) => sourceRank(left) - sourceRank(right) || left.name.localeCompare(right.name))
+}
+
+async function projectRoots(projectDir?: string) {
+    if (!projectDir) return []
+    const roots: string[] = []
+    let current = projectDir
+
+    while (true) {
+        roots.push(current)
+        if (await Bun.file(join(current, ".git")).exists()) break
+        const parent = dirname(current)
+        if (parent === current) break
+        current = parent
+    }
+
+    return roots.reverse()
+}
+
+async function loadSkillDir(registry: Map<string, SkillInfo>, dir: string, source: SnippetSource) {
+    let entries: string[]
+    try {
+        entries = await Array.fromAsync(new Bun.Glob(`*/${SKILL_FILE}`).scan({ cwd: dir, onlyFiles: true }))
+    } catch {
+        return
+    }
+
+    for (const entry of entries) {
+        const skill = await loadSkill(join(dir, entry), source)
+        if (skill) registry.set(skill.name.toLowerCase(), skill)
+    }
+}
+
+async function loadSkill(filePath: string, source: SnippetSource) {
+    let raw: string
+    try {
+        raw = await Bun.file(filePath).text()
+    } catch {
+        return undefined
+    }
+
+    const parsed = parseFrontmatter(raw)
+    const folderName = parse(dirname(filePath)).base
+    const name = typeof parsed.data.name === "string" && parsed.data.name.trim() ? parsed.data.name.trim() : folderName
+
+    return {
+        name,
+        content: parsed.content.trim(),
+        description: typeof parsed.data.description === "string" ? parsed.data.description : undefined,
+        filePath,
+        source,
+    } satisfies SkillInfo
+}
+
+function sourceRank(skill: SkillInfo) {
+    return skill.source === "project" ? 0 : 1
+}

package/src/modules/snippets/state.ts

@@ -0,0 +1,40 @@
+import { dirname, join } from "node:path"
+import { mkdir, writeFile } from "node:fs/promises"
+
+const SCOPE_GLOBAL = "__global__"
+
+export async function addPendingDraft(workspaceDir: string | undefined, name: string) {
+    const filePath = statePath("pending-drafts.json")
+    const state = await readState(filePath)
+    const scope = workspaceDir || SCOPE_GLOBAL
+    const current = Array.isArray(state[scope]) ? state[scope].filter((item): item is string => typeof item === "string") : []
+    const next = new Set([...current, name.toLowerCase()])
+    state[scope] = [...next].sort()
+    await writeState(filePath, state)
+}
+
+export async function markSnippetReloadRequested(workspaceDir?: string) {
+    const filePath = statePath("snippet-reload.json")
+    const state = await readState(filePath)
+    state[workspaceDir || SCOPE_GLOBAL] = Date.now()
+    await writeState(filePath, state)
+}
+
+function statePath(name: string) {
+    const home = process.env.HOME
+    if (!home) throw new Error("HOME is not set")
+    return join(home, ".config/opencode/state", name)
+}
+
+async function readState(filePath: string) {
+    try {
+        const parsed = JSON.parse(await Bun.file(filePath).text())
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed as Record<string, unknown>
+    } catch {}
+    return {} as Record<string, unknown>
+}
+
+async function writeState(filePath: string, state: Record<string, unknown>) {
+    await mkdir(dirname(filePath), { recursive: true })
+    await writeFile(filePath, `${JSON.stringify(state, null, 2)}\n`)
+}

package/src/modules/snippets/trigger.ts

@@ -0,0 +1,60 @@
+import type { HashtagTriggerMatch, SnippetInfo } from "./types"
+
+const HASHTAG_TRIGGER = /(^|\s)#([^\s#]*)$/
+
+export function findTrailingHashtagTrigger(input: string): HashtagTriggerMatch | undefined {
+    const match = HASHTAG_TRIGGER.exec(input)
+    if (!match) return undefined
+
+    const query = match[2] ?? ""
+    const token = `#${query}`
+
+    return {
+        start: input.length - token.length,
+        end: input.length,
+        query,
+        token,
+    }
+}
+
+export function replaceTrailingHashtag(input: string, name: string) {
+    const match = findTrailingHashtagTrigger(input)
+    if (!match) return input
+    return `${input.slice(0, match.start)}#${name} `
+}
+
+export function insertSnippetTag(input: string, name: string) {
+    const match = findTrailingHashtagTrigger(input)
+    if (match) return replaceTrailingHashtag(input, name)
+    const separator = input.length === 0 || /\s$/.test(input) ? "" : " "
+    return `${input}${separator}#${name} `
+}
+
+export function insertSkillLoad(input: string, name: string) {
+    const tag = `skill(${name})`
+    const match = findTrailingHashtagTrigger(input)
+    if (match) return replaceTrailingHashtag(input, tag)
+    const separator = input.length === 0 || /\s$/.test(input) ? "" : " "
+    return `${input}${separator}#${tag} `
+}
+
+export function preferredSnippetTag(input: string, snippet: SnippetInfo) {
+    const query = findTrailingHashtagTrigger(input)?.query
+    if (query && snippet.aliases.some((alias) => alias === query)) return query
+    return snippet.name
+}
+
+export function insertSnippetTrigger(input: string) {
+    if (findTrailingHashtagTrigger(input)) return input
+    const separator = input.length === 0 || /\s$/.test(input) ? "" : " "
+    return `${input}${separator}#`
+}
+
+export function isReloadCommand(input: string) {
+    return input.trim() === "/snippets:reload"
+}
+
+export function stepSelection(current: number, total: number, delta: number) {
+    if (total <= 0) return 0
+    return Math.max(0, Math.min(total - 1, current + delta))
+}

package/src/modules/snippets/types.ts

@@ -0,0 +1,49 @@
+export type SnippetSource = "global" | "project"
+
+export type SnippetInfo = {
+    name: string
+    content: string
+    aliases: string[]
+    description?: string
+    filePath: string
+    source: SnippetSource
+}
+
+export type SkillInfo = {
+    name: string
+    content: string
+    description?: string
+    filePath: string
+    source: SnippetSource
+}
+
+export type AutocompleteItem =
+    | {
+          kind: "snippet"
+          id: string
+          label: string
+          description: string
+          aliases: string[]
+          snippet: SnippetInfo
+      }
+    | {
+          kind: "skill"
+          id: string
+          label: string
+          description: string
+          aliases: string[]
+          skill: SkillInfo
+      }
+
+export type HashtagTriggerMatch = {
+    start: number
+    end: number
+    query: string
+    token: string
+}
+
+export type SnippetController = {
+    accept?: () => boolean
+    reload?: () => void
+    insertTrigger?: () => void
+}