@mirrowel/opencode-souk 0.1.0

package/dist/registry.d.ts

@@ -0,0 +1,67 @@
+import type { CacheFile, ItemKind, RegistryItem, SidecarConfig } from "./config.js";
+export declare function loadRegistry(config: SidecarConfig, options?: {
+    force?: boolean;
+}): Promise<CacheFile>;
+declare function normalizeCafe(raw: unknown): RegistryItem | undefined;
+declare function normalizeAwesome(raw: unknown): RegistryItem | undefined;
+declare function parseDocs(markdown: string): RegistryItem[];
+export declare function normalizeKind(type: string | undefined, raw?: Record<string, unknown>): ItemKind;
+declare function dedupe(items: RegistryItem[]): {
+    id: string;
+    source: "opencode-cafe" | "awesome-opencode" | "opencode-docs" | "installed";
+    kind: "plugin" | "mcp" | "agent" | "command" | "theme" | "skill" | "tool" | "app" | "project" | "resource" | "unknown";
+    confidence: "verified" | "partial" | "unmapped" | "unvetted" | "blocked";
+    name: string;
+    description: string;
+    tags: string[];
+    aliases: string[];
+    alternateKinds: ("plugin" | "mcp" | "agent" | "command" | "theme" | "skill" | "tool" | "app" | "project" | "resource" | "unknown")[];
+    sources: {
+        source: "opencode-cafe" | "awesome-opencode" | "opencode-docs" | "installed";
+        id?: string | undefined;
+        sourceType?: string | undefined;
+        name?: string | undefined;
+        description?: string | undefined;
+        repoUrl?: string | undefined;
+        homepageUrl?: string | undefined;
+        kind?: "plugin" | "mcp" | "agent" | "command" | "theme" | "skill" | "tool" | "app" | "project" | "resource" | "unknown" | undefined;
+        confidence?: "verified" | "partial" | "unmapped" | "unvetted" | "blocked" | undefined;
+        install?: {
+            type?: "plugin" | "mcp" | "agent" | "command" | "theme" | "skill" | undefined;
+            spec?: string | undefined;
+            specs?: string[] | undefined;
+            name?: string | undefined;
+            config?: Record<string, unknown> | undefined;
+            reason?: string | undefined;
+            verified?: boolean | undefined;
+        } | undefined;
+        installationMarkdown?: string | undefined;
+        updatedAt?: string | undefined;
+    }[];
+    warnings: string[];
+    sourceType?: string | undefined;
+    repoUrl?: string | undefined;
+    homepageUrl?: string | undefined;
+    primarySource?: "opencode-cafe" | "awesome-opencode" | "opencode-docs" | "installed" | undefined;
+    installationMarkdown?: string | undefined;
+    install?: {
+        type?: "plugin" | "mcp" | "agent" | "command" | "theme" | "skill" | undefined;
+        spec?: string | undefined;
+        specs?: string[] | undefined;
+        name?: string | undefined;
+        config?: Record<string, unknown> | undefined;
+        reason?: string | undefined;
+        verified?: boolean | undefined;
+    } | undefined;
+    updatedAt?: string | undefined;
+}[];
+declare function canonicalRepoKey(url: string | undefined): string | undefined;
+export declare const registryTestHooks: {
+    normalizeCafe: typeof normalizeCafe;
+    normalizeAwesome: typeof normalizeAwesome;
+    parseDocs: typeof parseDocs;
+    normalizeKind: typeof normalizeKind;
+    dedupe: typeof dedupe;
+    canonicalRepoKey: typeof canonicalRepoKey;
+};
+export {};

package/dist/registry.js

@@ -0,0 +1,447 @@
+import { CacheFile as CacheSchema, debugLog, loadCache, saveCache } from "./config.js";
+const SOURCE_TRUST = {
+    "opencode-cafe": 30,
+    "opencode-docs": 20,
+    "awesome-opencode": 15,
+};
+const KIND_PRIORITY = ["plugin", "mcp", "agent", "command", "theme", "skill", "tool", "app", "project", "resource", "unknown"];
+export async function loadRegistry(config, options = {}) {
+    const cached = loadCache();
+    if (!options.force && cached.items.length > 0) {
+        debugLog("Registry cache hit", `${cached.items.length} item(s); fetched=${cached.fetchedAt ?? "never"}`);
+        return cached;
+    }
+    const started = Date.now();
+    const fetches = [
+        config.sources.opencode_cafe.enabled ? fetchCafe(config.sources.opencode_cafe.url) : skipped("opencode-cafe"),
+        config.sources.awesome_opencode.enabled ? fetchAwesome(config.sources.awesome_opencode.url) : skipped("awesome-opencode"),
+        config.sources.opencode_docs.enabled ? fetchDocs(config.sources.opencode_docs.url) : skipped("opencode-docs"),
+    ];
+    const settled = await Promise.allSettled(fetches);
+    const items = [];
+    const errors = {};
+    const sourceStatus = {};
+    for (const result of settled) {
+        if (result.status === "rejected") {
+            errors.unknown = String(result.reason);
+            continue;
+        }
+        const status = result.value;
+        items.push(...status.items);
+        if (status.error)
+            errors[status.source] = status.error;
+        sourceStatus[status.source] = {
+            enabled: status.enabled,
+            status: status.enabled ? status.error ? "failed" : "fetched" : "skipped",
+            rawCount: status.rawCount,
+            normalizedCount: status.items.length,
+            warnings: status.warnings,
+            error: status.error,
+        };
+        if (status.enabled && status.rawCount > 0 && status.items.length === 0 && !status.error) {
+            errors[status.source] = `Source returned ${status.rawCount} raw item(s), but Souk normalized 0.`;
+        }
+    }
+    const next = CacheSchema.parse({
+        version: 1,
+        fetchedAt: new Date().toISOString(),
+        items: dedupe(items),
+        errors,
+        sourceStatus,
+    });
+    debugLog("Registry refresh", `${next.items.length} item(s), raw=${items.length}, ${Object.keys(errors).length} error(s), ${Date.now() - started}ms`);
+    if (next.items.length > 0 || Object.keys(errors).length > 0)
+        saveCache(next);
+    return next.items.length > 0 ? next : cached;
+}
+function skipped(source) {
+    return Promise.resolve({ source, enabled: false, rawCount: 0, items: [], warnings: [] });
+}
+async function fetchCafe(url) {
+    const source = "opencode-cafe";
+    if (!url)
+        return { source, enabled: true, rawCount: 0, items: [], warnings: [], error: "No URL configured" };
+    try {
+        const response = await fetch(url, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ path: "extensions:listAllApproved", args: {}, format: "json" }),
+        });
+        if (!response.ok)
+            throw new Error(`${response.status} ${response.statusText}`);
+        const json = await response.json();
+        const raw = Array.isArray(json) ? json : Array.isArray(json?.value) ? json.value : [];
+        const items = raw.map(normalizeCafe).filter(Boolean);
+        return { source, enabled: true, rawCount: raw.length, items, warnings: raw.length && !items.length ? ["No cafe entries normalized."] : [] };
+    }
+    catch (error) {
+        return { source, enabled: true, rawCount: 0, items: [], warnings: [], error: error instanceof Error ? error.message : String(error) };
+    }
+}
+async function fetchAwesome(url) {
+    const source = "awesome-opencode";
+    if (!url)
+        return { source, enabled: true, rawCount: 0, items: [], warnings: [], error: "No URL configured" };
+    try {
+        const response = await fetch(url);
+        if (!response.ok)
+            throw new Error(`${response.status} ${response.statusText}`);
+        const json = await response.json();
+        const list = Array.isArray(json) ? json : Array.isArray(json?.items) ? json.items : flattenRegistry(json);
+        const items = list.map(normalizeAwesome).filter(Boolean);
+        return { source, enabled: true, rawCount: list.length, items, warnings: list.length && !items.length ? ["No awesome-opencode entries normalized. Check registry field names."] : [] };
+    }
+    catch (error) {
+        return { source, enabled: true, rawCount: 0, items: [], warnings: [], error: error instanceof Error ? error.message : String(error) };
+    }
+}
+async function fetchDocs(url) {
+    const source = "opencode-docs";
+    if (!url)
+        return { source, enabled: true, rawCount: 0, items: [], warnings: [], error: "No URL configured" };
+    try {
+        const response = await fetch(url);
+        if (!response.ok)
+            throw new Error(`${response.status} ${response.statusText}`);
+        const markdown = await response.text();
+        const rows = docsRows(markdown);
+        const items = parseDocs(markdown);
+        return { source, enabled: true, rawCount: rows.length, items, warnings: rows.length && !items.length ? ["No docs ecosystem rows normalized."] : [] };
+    }
+    catch (error) {
+        return { source, enabled: true, rawCount: 0, items: [], warnings: [], error: error instanceof Error ? error.message : String(error) };
+    }
+}
+function normalizeCafe(raw) {
+    if (!isRecord(raw))
+        return;
+    const sourceID = stringValue(raw.productId) ?? stringValue(raw._id);
+    const name = stringValue(raw.displayName) ?? stringValue(raw.name) ?? sourceID;
+    if (!name)
+        return;
+    const sourceType = stringValue(raw.type);
+    const kind = normalizeKind(sourceType, raw);
+    const installation = stringValue(raw.installation);
+    const repoUrl = stringValue(raw.repoUrl);
+    const homepageUrl = stringValue(raw.homepageUrl);
+    return withSource({
+        id: `opencode-cafe:${slug(sourceID ?? name)}`,
+        source: "opencode-cafe",
+        sourceType,
+        kind,
+        confidence: confidenceFor(kind, installation, repoUrl),
+        name,
+        description: stringValue(raw.description) ?? "",
+        repoUrl,
+        homepageUrl,
+        tags: stringArray(raw.tags),
+        aliases: [sourceID].filter((item) => !!item && item !== name),
+        installationMarkdown: installation,
+        install: extractInstallHint(installation, kind),
+        warnings: warningsFor(kind, installation),
+        updatedAt: numberDate(raw.updatedAt) ?? numberDate(raw.reviewedAt) ?? numberDate(raw.createdAt) ?? stringValue(raw.updatedAt),
+    });
+}
+function normalizeAwesome(raw) {
+    if (!isRecord(raw))
+        return;
+    const productID = stringValue(raw.productId);
+    const name = stringValue(raw.displayName) ?? stringValue(raw.name) ?? productID;
+    if (!name)
+        return;
+    const sourceType = stringValue(raw.type) ?? stringValue(raw.category);
+    const kind = normalizeKind(sourceType, raw);
+    const repoUrl = stringValue(raw.repoUrl) ?? stringValue(raw.repo);
+    const homepageUrl = stringValue(raw.homepageUrl) ?? stringValue(raw.homepage);
+    const installation = stringValue(raw.installation);
+    return withSource({
+        id: `awesome-opencode:${slug(productID ?? name)}`,
+        source: "awesome-opencode",
+        sourceType,
+        kind,
+        confidence: confidenceFor(kind, installation, repoUrl),
+        name,
+        description: stringValue(raw.description) ?? stringValue(raw.tagline) ?? "",
+        repoUrl,
+        homepageUrl,
+        tags: [...stringArray(raw.tags), ...stringArray(raw.scope).map((scope) => `scope:${scope}`)],
+        aliases: [productID].filter((item) => !!item && item !== name),
+        installationMarkdown: installation,
+        install: extractInstallHint(installation, kind),
+        warnings: warningsFor(kind, installation),
+    });
+}
+function parseDocs(markdown) {
+    const lines = markdown.split(/\r?\n/);
+    let section = "unknown";
+    const items = [];
+    for (const line of lines) {
+        const header = /^##\s+(.+)$/.exec(line);
+        if (header) {
+            section = header[1]?.trim() ?? "unknown";
+            continue;
+        }
+        const row = /^\|\s*\[([^\]]+)\]\(([^)]+)\)\s*\|\s*([^|]+)\|/.exec(line);
+        if (!row)
+            continue;
+        const name = row[1]?.trim();
+        const repo = row[2]?.trim();
+        if (!name)
+            continue;
+        const kind = normalizeKind(section, { name, description: row[3] });
+        items.push(withSource({
+            id: `opencode-docs:${slug(section)}:${slug(name)}`,
+            source: "opencode-docs",
+            sourceType: section,
+            kind,
+            confidence: confidenceFor(kind, undefined, repo),
+            name,
+            description: row[3]?.trim() ?? "",
+            repoUrl: repo,
+            tags: [],
+            warnings: kind === "plugin" ? ["Docs entry does not include a package spec; inspect before installing."] : ["Docs ecosystem entry may need Forge or manual installation."],
+        }));
+    }
+    return items;
+}
+function docsRows(markdown) {
+    return markdown.split(/\r?\n/).filter((line) => /^\|\s*\[[^\]]+\]\([^)]+\)\s*\|\s*[^|]+\|/.test(line));
+}
+export function normalizeKind(type, raw = {}) {
+    const normalized = (type ?? "").toLowerCase().replace(/_/g, "-").trim();
+    if (["plugin", "plugins", "tui-plugin", "server-plugin"].includes(normalized))
+        return "plugin";
+    if (["mcp", "mcps", "mcp-server", "mcp-servers"].includes(normalized))
+        return "mcp";
+    if (["slash-command", "slash-commands", "command", "commands"].includes(normalized))
+        return "command";
+    if (["agent", "agents"].includes(normalized))
+        return "agent";
+    if (["theme", "themes"].includes(normalized))
+        return "theme";
+    if (["skill", "skills"].includes(normalized))
+        return "skill";
+    if (["tool", "tools"].includes(normalized))
+        return "tool";
+    if (["web-view", "webview", "app", "apps"].includes(normalized))
+        return "app";
+    if (["fork", "project", "projects"].includes(normalized))
+        return "project";
+    if (["resource", "resources", "discussion", "docs"].includes(normalized))
+        return "resource";
+    const haystack = `${stringValue(raw.name) ?? ""} ${stringValue(raw.displayName) ?? ""} ${stringValue(raw.productId) ?? ""} ${stringValue(raw.description) ?? ""} ${stringValue(raw.tagline) ?? ""} ${stringArray(raw.tags).join(" ")}`.toLowerCase();
+    if (/\bmcp\b/.test(haystack))
+        return "mcp";
+    if (/\bskill\b|skill\.md/.test(haystack))
+        return "skill";
+    if (/\bagent\b/.test(haystack))
+        return "agent";
+    if (/\bcommand\b|slash command/.test(haystack))
+        return "command";
+    if (/\btheme\b/.test(haystack))
+        return "theme";
+    if (/\bplugin\b|opencode-/.test(haystack))
+        return "plugin";
+    return "unknown";
+}
+function extractInstallHint(text, kind) {
+    if (!text)
+        return undefined;
+    const specs = Array.from(text.matchAll(/["']plugin["']\s*:\s*\[\s*((?:["'][^"']+["']\s*,?\s*)+)/gm))
+        .flatMap((match) => Array.from(match[1]?.matchAll(/["']([^"']+)["']/g) ?? []).map((entry) => entry[1]).filter((entry) => !!entry));
+    if (specs.length)
+        return { type: "plugin", spec: specs[0], specs: Array.from(new Set(specs)), reason: "Found OpenCode plugin config snippet", verified: true };
+    const barePlugin = /opencode\s+(?:plugin|plug)\s+([^\s`]+)/im.exec(text);
+    if (barePlugin?.[1])
+        return { type: "plugin", spec: barePlugin[1], specs: [barePlugin[1]], reason: "Found OpenCode plugin install command", verified: true };
+    if (/["']mcp["']\s*:\s*\{/m.test(text))
+        return { type: "mcp", reason: "Found OpenCode MCP config snippet", verified: true };
+    if (/\bmcpServers\b/m.test(text))
+        return { type: "mcp", reason: "Found Claude mcpServers config; conversion requires approval", verified: false };
+    if (kind === "plugin" && /^(@?[\w.-]+\/[\w.-]+|@?[\w.-]+)$/.test(text.trim()))
+        return { type: "plugin", spec: text.trim(), specs: [text.trim()], verified: true };
+    return undefined;
+}
+function confidenceFor(kind, installation, repoUrl) {
+    const hint = extractInstallHint(installation, kind);
+    if (hint?.verified && (hint.spec || hint.type === "mcp"))
+        return "verified";
+    if (["plugin", "mcp", "agent", "command", "theme", "skill"].includes(kind) && (installation || repoUrl))
+        return "partial";
+    if (["tool", "app", "project", "resource"].includes(kind))
+        return "unmapped";
+    return "unvetted";
+}
+function warningsFor(kind, installation) {
+    const warnings = [];
+    if (!installation)
+        warnings.push("No installation instructions were found in the source.");
+    if (installation && /curl\s+[^|]+\|\s*(?:sh|bash)|rm\s+-rf|sudo\s+/i.test(installation))
+        warnings.push("Installation text contains shell commands that need security review.");
+    if (installation && /\bmcpServers\b/m.test(installation))
+        warnings.push("Claude mcpServers config requires explicit conversion approval before native OpenCode install.");
+    if (["tool", "app", "project", "resource", "unknown"].includes(kind))
+        warnings.push("This item is not a deterministic native install target yet; use Forge if needed.");
+    if (installation && !extractInstallHint(installation, kind) && ["plugin", "mcp", "agent", "command", "theme", "skill"].includes(kind))
+        warnings.push("Install instructions exist but Souk could not prove a deterministic native install hint.");
+    return warnings;
+}
+function dedupe(items) {
+    const groups = new Map();
+    for (const item of items) {
+        const key = dedupeKey(item);
+        groups.set(key, [...(groups.get(key) ?? []), item]);
+    }
+    return Array.from(groups.entries()).map(([key, group]) => mergeGroup(key, group)).sort((a, b) => confidenceRank(a.confidence) - confidenceRank(b.confidence) || a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name));
+}
+function mergeGroup(key, group) {
+    const primary = [...group].sort((a, b) => sourceScore(b) - sourceScore(a))[0] ?? group[0];
+    const allSources = uniqueSources(group.flatMap((item) => item.sources.length ? item.sources : [sourceRef(item)]));
+    const kinds = Array.from(new Set(group.map((item) => item.kind))).sort((a, b) => KIND_PRIORITY.indexOf(a) - KIND_PRIORITY.indexOf(b));
+    const kind = kinds[0] ?? primary.kind;
+    const install = bestInstall(group);
+    const installationMarkdown = group.find((item) => item.installationMarkdown)?.installationMarkdown;
+    const aliases = Array.from(new Set(group.flatMap((item) => [item.name, ...item.aliases]).filter(Boolean))).filter((alias) => alias !== primary.name);
+    const descriptions = group.map((item) => item.description).filter(Boolean).sort((a, b) => b.length - a.length);
+    return {
+        ...primary,
+        id: group.length > 1 ? `combo:${slug(key)}` : primary.id,
+        source: primary.source,
+        primarySource: primary.source,
+        sourceType: primary.sourceType,
+        kind,
+        alternateKinds: kinds.filter((item) => item !== kind),
+        confidence: bestConfidence(group),
+        description: descriptions[0] ?? primary.description,
+        repoUrl: bestRepoUrl(group) ?? primary.repoUrl,
+        homepageUrl: group.find((item) => item.homepageUrl)?.homepageUrl,
+        tags: Array.from(new Set(group.flatMap((item) => item.tags))).sort(),
+        aliases,
+        sources: allSources,
+        installationMarkdown,
+        install,
+        warnings: Array.from(new Set(group.flatMap((item) => item.warnings))),
+        updatedAt: latestDate(group.map((item) => item.updatedAt)),
+    };
+}
+function dedupeKey(item) {
+    const repo = canonicalRepoKey(item.repoUrl);
+    if (repo)
+        return `repo:${repo}`;
+    const spec = item.install?.spec ?? item.install?.specs?.[0];
+    if (spec)
+        return `spec:${spec.toLowerCase()}`;
+    const homepage = canonicalUrl(item.homepageUrl);
+    if (homepage)
+        return `home:${homepage}`;
+    return `name:${slug(item.name)}:${item.kind}`;
+}
+function sourceScore(item) {
+    const installScore = item.install?.verified ? 60 : item.install?.spec || item.install?.type ? 30 : 0;
+    const confidenceScore = Math.max(0, 40 - confidenceRank(item.confidence) * 10);
+    const sourceScore = item.source === "installed" ? 0 : SOURCE_TRUST[item.source];
+    const descScore = Math.min(10, Math.floor((item.description?.length ?? 0) / 40));
+    const repoScore = item.repoUrl ? 8 : 0;
+    return installScore + confidenceScore + sourceScore + descScore + repoScore;
+}
+function bestInstall(group) {
+    return [...group].filter((item) => item.install).sort((a, b) => sourceScore(b) - sourceScore(a))[0]?.install;
+}
+function bestConfidence(group) {
+    return [...group].sort((a, b) => confidenceRank(a.confidence) - confidenceRank(b.confidence))[0]?.confidence ?? "unvetted";
+}
+function bestRepoUrl(group) {
+    return [...group].sort((a, b) => sourceScore(b) - sourceScore(a)).find((item) => item.repoUrl)?.repoUrl;
+}
+function sourceRef(item) {
+    return {
+        source: item.source,
+        id: item.id,
+        sourceType: item.sourceType,
+        name: item.name,
+        description: item.description,
+        repoUrl: item.repoUrl,
+        homepageUrl: item.homepageUrl,
+        kind: item.kind,
+        confidence: item.confidence,
+        install: item.install,
+        installationMarkdown: item.installationMarkdown,
+        updatedAt: item.updatedAt,
+    };
+}
+function withSource(item) {
+    const full = { ...item, aliases: item.aliases ?? [], alternateKinds: item.alternateKinds ?? [], sources: item.sources ?? [] };
+    return { ...full, primarySource: full.source, sources: [sourceRef(full)] };
+}
+function uniqueSources(sources) {
+    const map = new Map();
+    for (const source of sources)
+        map.set(`${source.source}:${source.id ?? source.name ?? source.repoUrl ?? "unknown"}`, source);
+    return Array.from(map.values()).sort((a, b) => a.source.localeCompare(b.source));
+}
+function canonicalRepoKey(url) {
+    const canonical = canonicalUrl(url);
+    if (!canonical)
+        return undefined;
+    try {
+        const parsed = new URL(canonical);
+        if (parsed.hostname !== "github.com")
+            return canonical;
+        const [owner, repo] = parsed.pathname.split("/").filter(Boolean);
+        if (!owner || !repo)
+            return canonical;
+        return `github.com/${owner.toLowerCase()}/${repo.toLowerCase().replace(/\.git$/, "")}`;
+    }
+    catch {
+        return canonical;
+    }
+}
+function canonicalUrl(url) {
+    if (!url)
+        return undefined;
+    try {
+        const parsed = new URL(url);
+        parsed.hash = "";
+        parsed.search = "";
+        parsed.pathname = parsed.pathname.replace(/\.git$/i, "").replace(/\/+$/g, "");
+        return parsed.toString().replace(/\/$/, "").toLowerCase();
+    }
+    catch {
+        return url.trim().toLowerCase().replace(/\.git$/i, "").replace(/\/+$/g, "") || undefined;
+    }
+}
+function latestDate(values) {
+    const dates = values.filter(Boolean).sort((a, b) => Date.parse(b) - Date.parse(a));
+    return dates[0];
+}
+function flattenRegistry(raw) {
+    if (!isRecord(raw))
+        return [];
+    return Object.entries(raw).flatMap(([type, value]) => Array.isArray(value) ? value.map((entry) => isRecord(entry) ? { ...entry, type } : entry) : []);
+}
+function confidenceRank(confidence) {
+    return ["verified", "partial", "unmapped", "unvetted", "blocked"].indexOf(confidence);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.trim().length > 0).map((item) => item.trim()) : [];
+}
+function numberDate(value) {
+    return typeof value === "number" ? new Date(value).toISOString() : undefined;
+}
+function slug(value) {
+    return value.toLowerCase().replace(/[^a-z0-9@._/-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+export const registryTestHooks = {
+    normalizeCafe,
+    normalizeAwesome,
+    parseDocs,
+    normalizeKind,
+    dedupe,
+    canonicalRepoKey,
+};

package/dist/server.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    id: string;
+    server: import("@opencode-ai/plugin").Plugin;
+};
+export default _default;

package/dist/server.js

@@ -0,0 +1,2 @@
+import plugin from "./index.js";
+export default { id: "opencode-souk", server: plugin };

package/dist/tui.d.ts

@@ -0,0 +1,6 @@
+import type { TuiPlugin } from "@opencode-ai/plugin/tui";
+declare const _default: {
+    id: string;
+    tui: TuiPlugin;
+};
+export default _default;