@mirrowel/opencode-souk 0.1.0

package/dist/config.js

@@ -0,0 +1,496 @@
+import { createHash } from "node:crypto";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { parse, stringify } from "comment-json";
+import { z } from "zod";
+export const ITEM_KINDS = ["plugin", "mcp", "agent", "command", "theme", "skill", "tool", "app", "project", "resource", "unknown"];
+export const CONFIDENCE = ["verified", "partial", "unmapped", "unvetted", "blocked"];
+export const SOURCES = ["opencode-cafe", "awesome-opencode", "opencode-docs", "installed"];
+export const PERSONALITY_PRESETS = [
+    "curio-shelf",
+    "expedition-cataloguer",
+    "the-fence",
+    "wayfinder",
+    "quartermaster",
+    "appraiser",
+    "the-souk",
+    "wary-antiquarian",
+    "friendly-stallkeeper",
+    "contract-scribe",
+    "pragmatic-artisan",
+    "sober-host",
+];
+export const InstallHint = z.object({
+    type: z.enum(["plugin", "mcp", "agent", "command", "theme", "skill"]).optional(),
+    spec: z.string().optional(),
+    specs: z.array(z.string()).optional(),
+    name: z.string().optional(),
+    config: z.record(z.string(), z.unknown()).optional(),
+    reason: z.string().optional(),
+    verified: z.boolean().optional(),
+});
+export const SourceRef = z.object({
+    source: z.enum(SOURCES),
+    id: z.string().optional(),
+    sourceType: z.string().optional(),
+    name: z.string().optional(),
+    description: z.string().optional(),
+    repoUrl: z.string().optional(),
+    homepageUrl: z.string().optional(),
+    kind: z.enum(ITEM_KINDS).optional(),
+    confidence: z.enum(CONFIDENCE).optional(),
+    install: InstallHint.optional(),
+    installationMarkdown: z.string().optional(),
+    updatedAt: z.string().optional(),
+});
+export const RegistryItem = z.object({
+    id: z.string().min(1),
+    source: z.enum(SOURCES),
+    sourceType: z.string().optional(),
+    kind: z.enum(ITEM_KINDS),
+    confidence: z.enum(CONFIDENCE),
+    name: z.string().min(1),
+    description: z.string().default(""),
+    repoUrl: z.string().optional(),
+    homepageUrl: z.string().optional(),
+    tags: z.array(z.string()).default([]),
+    aliases: z.array(z.string()).default([]),
+    alternateKinds: z.array(z.enum(ITEM_KINDS)).default([]),
+    sources: z.array(SourceRef).default([]),
+    primarySource: z.enum(SOURCES).optional(),
+    installationMarkdown: z.string().optional(),
+    install: InstallHint.optional(),
+    warnings: z.array(z.string()).default([]),
+    updatedAt: z.string().optional(),
+});
+const SourceSettings = z.object({
+    enabled: z.boolean().default(true),
+    url: z.string().url().optional(),
+});
+const UiSettings = z.object({
+    width: z.enum(["medium", "large", "xlarge"]).default("large"),
+    height: z.enum(["compact", "normal", "tall", "max"]).default("tall"),
+    height_percent: z.number().int().min(25).max(100).default(68),
+    browser: z.object({
+        width: z.enum(["medium", "large", "xlarge"]).default("xlarge"),
+    }).default({ width: "xlarge" }),
+}).default({ width: "large", height: "tall", height_percent: 68, browser: { width: "xlarge" } });
+const CacheSettings = z.object({
+    fetch_on_empty: z.boolean().default(true),
+    refresh_manually: z.boolean().default(true),
+    stale_after_hours: z.number().int().min(1).default(168),
+}).default({ fetch_on_empty: true, refresh_manually: true, stale_after_hours: 168 });
+const InstallSettings = z.object({
+    default_scope: z.enum(["ask", "global", "project"]).default("ask"),
+    conflict_policy: z.enum(["refuse"]).default("refuse"),
+    allow_claude_mcp_conversion: z.enum(["ask", "never"]).default("ask"),
+    runtime_mcp_connect: z.boolean().default(true),
+}).default({ default_scope: "ask", conflict_policy: "refuse", allow_claude_mcp_conversion: "ask", runtime_mcp_connect: true });
+const ForgeAgentSettings = z.object({
+    model: z.string().min(1).default("opencode/big-pickle"),
+    variant: z.string().optional(),
+    temperature: z.number().finite().optional(),
+    top_p: z.number().finite().optional(),
+    options: z.record(z.string(), z.unknown()).optional(),
+    personality: z.enum(PERSONALITY_PRESETS).default("curio-shelf"),
+});
+const ForgeSettings = z.object({
+    enabled: z.boolean().default(false),
+    bulk: z.boolean().default(true),
+    require_typed_high_risk: z.boolean().default(true),
+    agent: ForgeAgentSettings.default({ model: "opencode/big-pickle", personality: "curio-shelf" }),
+}).default({ enabled: false, bulk: true, require_typed_high_risk: true, agent: { model: "opencode/big-pickle", personality: "curio-shelf" } });
+export const SidecarConfig = z.object({
+    debug: z.boolean().default(false),
+    ui: UiSettings,
+    cache: CacheSettings,
+    install: InstallSettings,
+    forge: ForgeSettings,
+    sources: z.object({
+        opencode_cafe: SourceSettings.default({ enabled: true, url: "https://curious-quail-727.convex.cloud/api/query" }),
+        awesome_opencode: SourceSettings.default({ enabled: true, url: "https://raw.githubusercontent.com/awesome-opencode/awesome-opencode/main/dist/registry.json" }),
+        opencode_docs: SourceSettings.default({ enabled: true, url: "https://raw.githubusercontent.com/anomalyco/opencode/dev/packages/web/src/content/docs/ecosystem.mdx" }),
+    }).default({
+        opencode_cafe: { enabled: true, url: "https://curious-quail-727.convex.cloud/api/query" },
+        awesome_opencode: { enabled: true, url: "https://raw.githubusercontent.com/awesome-opencode/awesome-opencode/main/dist/registry.json" },
+        opencode_docs: { enabled: true, url: "https://raw.githubusercontent.com/anomalyco/opencode/dev/packages/web/src/content/docs/ecosystem.mdx" },
+    }),
+    hidden: z.record(z.string(), z.boolean()).default({}),
+});
+const BackupOperation = z.object({
+    op: z.enum(["add", "remove", "replace"]),
+    path: z.array(z.union([z.string(), z.number()])),
+    value: z.unknown().optional(),
+});
+const PatchBackupEntry = z.object({
+    type: z.literal("patch"),
+    id: z.string(),
+    timestamp: z.string(),
+    before_hash: z.string(),
+    after_hash: z.string(),
+    changed_paths: z.array(z.string()),
+    reverse_patch: z.array(BackupOperation),
+});
+const FullBackupEntry = z.object({
+    type: z.literal("full"),
+    id: z.string(),
+    timestamp: z.string(),
+    hash: z.string(),
+    label: z.string().optional(),
+    config: SidecarConfig,
+});
+export const BackupJournal = z.object({
+    version: z.literal(1).default(1),
+    patch_limit: z.number().int().min(1).default(50),
+    patches: z.array(PatchBackupEntry).default([]),
+    full: z.array(FullBackupEntry).default([]),
+});
+export const CacheFile = z.object({
+    version: z.literal(1).default(1),
+    fetchedAt: z.string().optional(),
+    items: z.array(RegistryItem).default([]),
+    errors: z.record(z.string(), z.string()).default({}),
+    sourceStatus: z.record(z.string(), z.object({
+        enabled: z.boolean().default(true),
+        status: z.enum(["fetched", "skipped", "failed"]).default("fetched"),
+        rawCount: z.number().int().min(0).default(0),
+        normalizedCount: z.number().int().min(0).default(0),
+        warnings: z.array(z.string()).default([]),
+        error: z.string().optional(),
+    })).default({}),
+});
+export function defaultConfigDir() {
+    if (process.env.OPENCODE_CONFIG_DIR)
+        return process.env.OPENCODE_CONFIG_DIR;
+    if (process.env.XDG_CONFIG_HOME)
+        return join(process.env.XDG_CONFIG_HOME, "opencode");
+    if (process.platform === "win32" && process.env.APPDATA)
+        return join(process.env.APPDATA, "opencode");
+    return join(homedir(), ".config", "opencode");
+}
+export function defaultSidecarPath() {
+    return join(defaultConfigDir(), "souk.jsonc");
+}
+export function defaultCachePath() {
+    return join(defaultConfigDir(), "souk-cache.json");
+}
+export function heightPresetPercent(height) {
+    if (height === "compact")
+        return 32;
+    if (height === "normal")
+        return 50;
+    if (height === "max")
+        return 100;
+    return 68;
+}
+export function effectiveUiHeightPercent(ui) {
+    return Math.max(25, Math.min(100, Math.round(ui.height_percent ?? heightPresetPercent(ui.height))));
+}
+export function debugLogPath(configDir = defaultConfigDir()) {
+    return join(configDir, "souk.debug.log");
+}
+export function backupJournalPath(configDir = defaultConfigDir()) {
+    return join(configDir, "souk.backup.json");
+}
+export function emptyConfig() {
+    return SidecarConfig.parse({});
+}
+export function emptyCache() {
+    return CacheFile.parse({ version: 1, items: [], errors: {} });
+}
+export function emptyBackupJournal() {
+    return BackupJournal.parse({ version: 1, patch_limit: 50, patches: [], full: [] });
+}
+export function loadSidecar(file = defaultSidecarPath()) {
+    if (!existsSync(file))
+        return emptyConfig();
+    return SidecarConfig.parse(parse(readFileSync(file, "utf8")));
+}
+export function loadSidecarSafe(file = defaultSidecarPath()) {
+    try {
+        return { config: loadSidecar(file) };
+    }
+    catch (error) {
+        return { config: emptyConfig(), error: error instanceof Error ? error.message : String(error) };
+    }
+}
+export function saveSidecar(config, file = defaultSidecarPath(), options = {}) {
+    const parsed = SidecarConfig.parse(config);
+    let previous;
+    if (existsSync(file)) {
+        try {
+            previous = loadSidecar(file);
+        }
+        catch (error) {
+            if (!options.allowInvalidPrevious)
+                throw error;
+        }
+    }
+    if (previous && stableStringify(previous) === stableStringify(parsed))
+        return { changed: false };
+    mkdirSync(dirname(file), { recursive: true });
+    if (previous && options.backup !== false)
+        writePatchBackup(previous, parsed, backupJournalPath(dirname(file)));
+    const temp = `${file}.tmp`;
+    writeFileSync(temp, `${stringify(parsed, null, 2)}\n`, "utf8");
+    renameSync(temp, file);
+    return { changed: true };
+}
+export function loadBackupJournal(file = backupJournalPath()) {
+    if (!existsSync(file))
+        return emptyBackupJournal();
+    return BackupJournal.parse(JSON.parse(readFileSync(file, "utf8")));
+}
+export function saveBackupJournal(journal, file = backupJournalPath()) {
+    const parsed = BackupJournal.parse(journal);
+    mkdirSync(dirname(file), { recursive: true });
+    const temp = `${file}.tmp`;
+    writeFileSync(temp, `${JSON.stringify(parsed, null, 2)}\n`, "utf8");
+    renameSync(temp, file);
+}
+export function hashConfig(config) {
+    return createHash("sha256").update(stableStringify(backupHashConfig(config))).digest("hex");
+}
+function backupHashConfig(config) {
+    const parsed = SidecarConfig.parse(config);
+    const { debug: _debug, ui: _ui, ...rest } = parsed;
+    return rest;
+}
+export function createFullBackup(config, input) {
+    const journal = loadBackupJournal(input?.file);
+    const now = new Date().toISOString();
+    journal.full.unshift({ type: "full", id: now, timestamp: now, hash: hashConfig(config), label: input?.label, config: SidecarConfig.parse(config) });
+    saveBackupJournal(journal, input?.file);
+    return journal;
+}
+export function deleteFullBackup(id, file = backupJournalPath()) {
+    const journal = loadBackupJournal(file);
+    journal.full = journal.full.filter((entry) => entry.id !== id);
+    saveBackupJournal(journal, file);
+    return journal;
+}
+export function deleteAllFullBackups(file = backupJournalPath()) {
+    const journal = loadBackupJournal(file);
+    journal.full = [];
+    saveBackupJournal(journal, file);
+    return journal;
+}
+export function reconstructPatchBackup(index, current, journal = loadBackupJournal()) {
+    let config = SidecarConfig.parse(current);
+    for (const [entryIndex, entry] of journal.patches.entries()) {
+        const currentHash = hashConfig(config);
+        if (currentHash !== entry.after_hash)
+            return { ok: false, message: `Hash mismatch at patch ${entryIndex + 1}. Current config is ${currentHash.slice(0, 8)}, expected ${entry.after_hash.slice(0, 8)}.` };
+        config = applyBackupOperations(config, entry.reverse_patch);
+        const restoredHash = hashConfig(config);
+        if (restoredHash !== entry.before_hash)
+            return { ok: false, message: `Patch ${entryIndex + 1} restored ${restoredHash.slice(0, 8)}, expected ${entry.before_hash.slice(0, 8)}.` };
+        if (entryIndex === index)
+            return { ok: true, config, consumed: entryIndex + 1 };
+    }
+    return { ok: false, message: "Patch backup was not found." };
+}
+function writePatchBackup(previous, next, file) {
+    const reverse = diffReverse(previous, next);
+    if (reverse.operations.length === 0)
+        return;
+    const journal = loadBackupJournal(file);
+    const now = new Date().toISOString();
+    journal.patches.unshift({ type: "patch", id: now, timestamp: now, before_hash: hashConfig(previous), after_hash: hashConfig(next), changed_paths: reverse.changed_paths, reverse_patch: reverse.operations });
+    journal.patches = journal.patches.slice(0, journal.patch_limit);
+    saveBackupJournal(journal, file);
+}
+function diffReverse(previous, next, path = []) {
+    if (stableStringify(previous) === stableStringify(next))
+        return { operations: [], changed_paths: [] };
+    if (!isPlainObject(previous) || !isPlainObject(next))
+        return { operations: [{ op: previous === undefined ? "remove" : next === undefined ? "add" : "replace", path, value: previous }], changed_paths: [formatPath(path)] };
+    return [...new Set([...Object.keys(previous), ...Object.keys(next)])]
+        .map((key) => diffReverse(previous[key], next[key], [...path, key]))
+        .reduce((acc, item) => ({ operations: [...acc.operations, ...item.operations], changed_paths: [...acc.changed_paths, ...item.changed_paths] }), { operations: [], changed_paths: [] });
+}
+function applyBackupOperations(config, operations) {
+    const result = structuredClone(config);
+    for (const operation of operations)
+        applyBackupOperation(result, operation);
+    return SidecarConfig.parse(result);
+}
+function applyBackupOperation(target, operation) {
+    const parent = operation.path.slice(0, -1).reduce((cursor, segment) => {
+        if (!isPlainObject(cursor[segment]))
+            cursor[segment] = {};
+        return cursor[segment];
+    }, target);
+    const key = operation.path.at(-1);
+    if (key === undefined)
+        return;
+    if (operation.op === "remove")
+        delete parent[key];
+    else
+        parent[key] = operation.value;
+}
+export function stableStringify(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableStringify).join(",")}]`;
+    if (isPlainObject(value))
+        return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",")}}`;
+    return JSON.stringify(value);
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function formatPath(path) {
+    return path.length === 0 ? "<root>" : path.join(".");
+}
+export function debugEnabled() {
+    try {
+        return loadSidecar(defaultSidecarPath()).debug;
+    }
+    catch {
+        return false;
+    }
+}
+export function debugLog(title, message, enabled = debugEnabled()) {
+    if (!enabled)
+        return;
+    try {
+        mkdirSync(defaultConfigDir(), { recursive: true });
+        appendFileSync(debugLogPath(defaultConfigDir()), `${new Date().toISOString()} ${title}: ${message}\n`, "utf8");
+    }
+    catch {
+        // Debug logging must never affect Souk behavior.
+    }
+}
+export function loadCache(file = defaultCachePath()) {
+    if (!existsSync(file))
+        return emptyCache();
+    try {
+        return CacheFile.parse(JSON.parse(readFileSync(file, "utf8")));
+    }
+    catch {
+        return emptyCache();
+    }
+}
+export function saveCache(cache, file = defaultCachePath()) {
+    mkdirSync(dirname(file), { recursive: true });
+    const temp = `${file}.tmp`;
+    writeFileSync(temp, JSON.stringify(cache, null, 2), "utf8");
+    renameSync(temp, file);
+}
+export function modelCatalogFromProviders(providers) {
+    const catalog = { providers: new Set(), providersWithModelList: new Set(), refs: new Set(), variants: new Map() };
+    const list = Array.isArray(providers) ? providers : Object.entries((providers ?? {})).map(([id, value]) => ({ id, ...value }));
+    for (const provider of list) {
+        const providerID = typeof provider.id === "string" ? provider.id : undefined;
+        if (!providerID)
+            continue;
+        catalog.providers.add(providerID);
+        const models = provider.models;
+        if (!models || Object.keys(models).length === 0)
+            continue;
+        catalog.providersWithModelList.add(providerID);
+        for (const [key, value] of Object.entries(models)) {
+            const refs = [`${providerID}/${key}`, typeof value.id === "string" ? `${providerID}/${value.id}` : undefined].filter((ref) => !!ref);
+            for (const ref of refs) {
+                catalog.refs.add(ref);
+                if (value.variants && Object.keys(value.variants).length > 0)
+                    catalog.variants.set(ref, new Set(Object.keys(value.variants)));
+            }
+        }
+    }
+    return catalog;
+}
+export function validateModel(model, catalog) {
+    if (!model)
+        return;
+    const split = splitModelRef(model);
+    if (!split)
+        return `Model "${model}" must use provider/model format.`;
+    if (!catalog.providers.has(split.providerID))
+        return `Provider "${split.providerID}" is not configured for model "${model}".`;
+    if (catalog.providersWithModelList.has(split.providerID) && !catalog.refs.has(model))
+        return `Model "${model}" was not found in provider "${split.providerID}".`;
+}
+export function validateModelVariant(model, variant, catalog) {
+    if (!variant || !model)
+        return;
+    const variants = catalog.variants.get(model);
+    if (variants && variants.size > 0 && !variants.has(variant))
+        return `Variant "${variant}" was not found for model "${model}".`;
+}
+export function diagnoseConfig(config, input = {}) {
+    const diagnostics = [];
+    const catalog = modelCatalogFromProviders(input.providers);
+    diagnostics.push({ level: "info", message: `Debug mode is ${config.debug ? "enabled" : "disabled"}.` });
+    if (input.configParseError)
+        diagnostics.push({ level: "error", message: `Sidecar config parse failed; defaults are active: ${input.configParseError}` });
+    const modelIssue = validateModel(config.forge.agent.model, catalog);
+    if (modelIssue)
+        diagnostics.push({ level: "warning", message: `Kāf model: ${modelIssue}` });
+    const variantIssue = validateModelVariant(config.forge.agent.model, config.forge.agent.variant, catalog);
+    if (variantIssue)
+        diagnostics.push({ level: "warning", message: `Kāf model variant: ${variantIssue}` });
+    for (const [name, source] of Object.entries(config.sources)) {
+        if (!source.enabled)
+            diagnostics.push({ level: "info", message: `Source ${name} is disabled.` });
+        if (source.enabled && !source.url)
+            diagnostics.push({ level: "warning", message: `Source ${name} is enabled but has no URL.` });
+    }
+    const cache = input.cache ?? loadCache();
+    diagnostics.push({ level: "info", message: `Cache has ${cache.items.length} item(s); fetched ${cache.fetchedAt ?? "never"}.` });
+    for (const [source, status] of Object.entries(cache.sourceStatus)) {
+        diagnostics.push({ level: status.error ? "warning" : "info", message: `Source ${source}: ${status.status}, raw ${status.rawCount}, normalized ${status.normalizedCount}${status.error ? `, error: ${status.error}` : ""}.` });
+        for (const warning of status.warnings)
+            diagnostics.push({ level: "warning", message: `Source ${source}: ${warning}` });
+    }
+    if (Object.keys(cache.errors).length > 0)
+        diagnostics.push({ level: "warning", message: `Cache has source errors: ${Object.entries(cache.errors).map(([key, value]) => `${key}: ${value}`).join("; ")}` });
+    if (cache.fetchedAt) {
+        const ageHours = (Date.now() - Date.parse(cache.fetchedAt)) / 3_600_000;
+        if (Number.isFinite(ageHours) && ageHours > config.cache.stale_after_hours)
+            diagnostics.push({ level: "warning", message: `Cache is stale (${Math.round(ageHours)}h old).` });
+    }
+    if (input.pluginIDs && !input.pluginIDs.includes("opencode-souk"))
+        diagnostics.push({ level: "warning", message: "Souk TUI plugin ID was not found in loaded plugin list." });
+    try {
+        const journal = loadBackupJournal();
+        diagnostics.push({ level: "info", message: `Backup journal has ${journal.patches.length} patch restore point(s) and ${journal.full.length} full backup(s).` });
+        if (journal.patches.length > 0) {
+            const restored = reconstructPatchBackup(0, config, journal);
+            if (!restored.ok)
+                diagnostics.push({ level: "warning", message: `Backup journal hash check failed: ${restored.message}` });
+        }
+    }
+    catch (error) {
+        diagnostics.push({ level: "warning", message: `Backup journal could not be read: ${error instanceof Error ? error.message : String(error)}` });
+    }
+    return diagnostics;
+}
+export function splitModelRef(ref) {
+    const [providerID, ...rest] = ref.split("/");
+    const modelID = rest.join("/");
+    if (!providerID || !modelID)
+        return undefined;
+    return { providerID, modelID };
+}
+export function confidenceRank(confidence) {
+    return CONFIDENCE.indexOf(confidence);
+}
+export function personalityDescription(preset) {
+    const map = {
+        "curio-shelf": "Quiet cabinet-of-curiosities voice; default. Atmosphere is light, warnings are plain.",
+        "expedition-cataloguer": "Meticulous artifact catalogue: provenance, condition, handling notes.",
+        "the-fence": "World-weary procurer. Blunt about sketchy goods.",
+        wayfinder: "Routes, maps, known terrain, and unmapped territory.",
+        quartermaster: "Procedural deployment/logistics voice.",
+        appraiser: "Authenticity, provenance, condition, and risk appraisal.",
+        "the-souk": "The marketplace itself as the character and institution.",
+        "wary-antiquarian": "Rare-artifact dealer who has seen cursed things.",
+        "friendly-stallkeeper": "Warm and protective market guide.",
+        "contract-scribe": "Formal, dry, exact, and safety-forward.",
+        "pragmatic-artisan": "Skilled craftsperson: practical, concise, honest.",
+        "sober-host": "Minimal personality, maximum clarity.",
+    };
+    return map[preset];
+}

package/dist/forge.d.ts

@@ -0,0 +1,3 @@
+import type { TuiPluginApi } from "@opencode-ai/plugin/tui";
+import type { RegistryItem, ScopeChoice, SidecarConfig } from "./config.js";
+export declare function openForge(api: TuiPluginApi, config: SidecarConfig, items: RegistryItem[], scope: ScopeChoice): Promise<string>;

package/dist/forge.js

@@ -0,0 +1,78 @@
+import { debugLog, personalityDescription, splitModelRef } from "./config.js";
+import { scopeLabel } from "./install.js";
+export async function openForge(api, config, items, scope) {
+    debugLog("Forge open start", `${items.length} item(s) -> ${scopeLabel(scope)}; model=${config.forge.agent.model}; variant=${config.forge.agent.variant ?? "default"}`);
+    const model = splitModelRef(config.forge.agent.model);
+    const title = items.length === 1 ? `Souk Forge: ${items[0]?.name ?? "item"}` : `Souk Forge: ${items.length} items`;
+    const client = api.client;
+    if (!client.session?.create || (!client.session.promptAsync && !client.session.prompt)) {
+        throw new Error("This OpenCode build does not expose session create/prompt APIs to TUI plugins.");
+    }
+    const created = unwrap(await client.session.create({
+        title,
+        agent: "kāf-plan",
+        ...(model ? { model: { providerID: model.providerID, id: model.modelID, variant: config.forge.agent.variant } } : {}),
+        permission: planPermission(),
+    }));
+    if (!created?.id)
+        throw new Error("Failed to create Souk Forge session.");
+    const prompt = forgePrompt(config, items, scope);
+    const payload = {
+        sessionID: created.id,
+        agent: "kāf-plan",
+        ...(model ? { model: { providerID: model.providerID, modelID: model.modelID }, variant: config.forge.agent.variant } : {}),
+        parts: [{ type: "text", text: prompt }],
+    };
+    if (client.session.promptAsync)
+        await client.session.promptAsync(payload);
+    else
+        await client.session.prompt?.(payload);
+    api.route.navigate("session", { sessionID: created.id });
+    debugLog("Forge open complete", created.id);
+    return created.id;
+}
+function forgePrompt(config, items, scope) {
+    return [
+        "You are Kāf, the dedicated OpenCode Souk Forge agent.",
+        "",
+        "Before doing anything else, load these skills with the skill tool:",
+        "- customize-opencode",
+        "- souk-installer",
+        "",
+        `Personality preset: ${config.forge.agent.personality}`,
+        personalityDescription(config.forge.agent.personality),
+        "",
+        "You are in PLAN MODE. You must not edit files, write config, run install commands, or mutate the system yet.",
+        "You may use MCP tools for research, inspection, and appraisal in plan mode when available. Do not use MCP tools to mutate files, config, accounts, remote services, or project state before action approval.",
+        "Analyze security first. Inspect provenance, install scripts, requested permissions, config writes, network/token handling, and stale docs risk.",
+        "When and only when you have a clear plan, call souk_request_action to ask the user yes/no before action mode.",
+        "If the user says no, continue planning and propose switching again only when appropriate.",
+        "",
+        `Requested scope: ${scopeLabel(scope)}`,
+        "Selected items:",
+        JSON.stringify(items, null, 2),
+    ].join("\n");
+}
+function planPermission() {
+    return [
+        { permission: "edit", pattern: "*", action: "deny" },
+        { permission: "write", pattern: "*", action: "deny" },
+        { permission: "patch", pattern: "*", action: "deny" },
+        { permission: "bash", pattern: "*", action: "deny" },
+        { permission: "skill", pattern: "*", action: "allow" },
+        { permission: "read", pattern: "*", action: "allow" },
+        { permission: "grep", pattern: "*", action: "allow" },
+        { permission: "glob", pattern: "*", action: "allow" },
+        { permission: "webfetch", pattern: "*", action: "allow" },
+        { permission: "websearch", pattern: "*", action: "allow" },
+        { permission: "souk_request_action", pattern: "*", action: "allow" },
+        { permission: "souk_registry_search", pattern: "*", action: "allow" },
+        { permission: "souk_native_preview", pattern: "*", action: "allow" },
+        { permission: "souk_native_install", pattern: "*", action: "deny" },
+    ];
+}
+function unwrap(result) {
+    if (result && typeof result === "object" && "data" in result)
+        return result.data;
+    return result;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "@opencode-ai/plugin";
+declare const plugin: Plugin;
+export default plugin;