opencode-prompt-expand 0.0.0-stage → 0.1.0

package/dist/model.js

@@ -0,0 +1,104 @@
+export function composerToRef(model) {
+    return {
+        providerID: model.providerID,
+        id: model.modelID,
+        ...(model.variant ? { variant: model.variant } : {}),
+    };
+}
+export function modelToRef(model) {
+    return {
+        providerID: model.providerID,
+        id: model.id,
+    };
+}
+export function modelLabel(model) {
+    return `${model.providerID}/${model.id}`;
+}
+export function parseExplicitModel(value) {
+    const index = value.indexOf("/");
+    if (index <= 0 || index === value.length - 1)
+        return null;
+    return { providerID: value.slice(0, index), id: value.slice(index + 1) };
+}
+export function findModel(models, ref) {
+    return models.find((model) => model.providerID === ref.providerID && (model.id === ref.id || model.modelID === ref.id));
+}
+function baseCost(model) {
+    if (!model.cost || model.cost.length === 0)
+        return undefined;
+    return model.cost.find((tier) => !tier.tier) ?? model.cost[0];
+}
+export function isCheapChat(model) {
+    if (model.enabled === false)
+        return false;
+    if (model.status === "deprecated")
+        return false;
+    if (model.type && model.type !== "chat")
+        return false;
+    const cost = baseCost(model);
+    if (!cost)
+        return true;
+    return cost.input < 1 && cost.output < 3;
+}
+function cheapestChat(models) {
+    return models
+        .filter((model) => isCheapChat(model))
+        .slice()
+        .sort((left, right) => {
+        const leftCost = baseCost(left);
+        const rightCost = baseCost(right);
+        const leftScore = leftCost ? leftCost.input + leftCost.output : 0;
+        const rightScore = rightCost ? rightCost.input + rightCost.output : 0;
+        return leftScore - rightScore;
+    })[0];
+}
+function anyChat(models) {
+    return models.find((model) => model.enabled !== false &&
+        model.status !== "deprecated" &&
+        (!model.type || model.type === "chat"));
+}
+export function pickModel(input) {
+    const preference = input.preference.trim();
+    if (preference && preference !== "auto" && preference !== "composer") {
+        const explicit = parseExplicitModel(preference);
+        if (explicit) {
+            const found = findModel(input.models, explicit);
+            return { model: found ? modelToRef(found) : explicit, source: "explicit" };
+        }
+    }
+    const composerRef = input.composerModel ? composerToRef(input.composerModel) : undefined;
+    if (preference === "composer") {
+        if (composerRef)
+            return { model: composerRef, source: "composer" };
+        if (input.sessionModel)
+            return { model: input.sessionModel, source: "session" };
+        if (input.defaultModel)
+            return { model: modelToRef(input.defaultModel), source: "default" };
+        const fallback = anyChat(input.models);
+        return fallback ? { model: modelToRef(fallback), source: "cheap" } : null;
+    }
+    // auto: composer model first, but avoid expensive models.
+    if (composerRef) {
+        const info = findModel(input.models, composerRef);
+        if (!info || isCheapChat(info)) {
+            return { model: composerRef, source: "composer" };
+        }
+    }
+    if (input.sessionModel) {
+        const info = findModel(input.models, input.sessionModel);
+        if (!info || isCheapChat(info)) {
+            return { model: input.sessionModel, source: "session" };
+        }
+    }
+    // With no composer/session model (Home or a draft), the server default is
+    // a better guess than the cheapest model: free models often have hard usage
+    // limits, which would make the fallback button fail immediately.
+    if (input.defaultModel && input.defaultModel.enabled !== false && input.defaultModel.status !== "deprecated") {
+        return { model: modelToRef(input.defaultModel), source: "default" };
+    }
+    const cheap = cheapestChat(input.models);
+    if (cheap)
+        return { model: modelToRef(cheap), source: "cheap" };
+    const fallback = anyChat(input.models);
+    return fallback ? { model: modelToRef(fallback), source: "cheap" } : null;
+}

package/dist/optimizer.js

@@ -0,0 +1,86 @@
+const STRUCTURE_MARKERS = [/目标/, /范围/, /要求/, /验收/];
+const CONFIRMATION = /^(继续|好的|收到|谢谢|可以|ok|okay|yes|no|go|continue|thanks?)[。.!！]?$/i;
+const MENTION = /(^|\s)@[\w./\\-]{2,}/;
+export function detectMention(text) {
+    return MENTION.test(text);
+}
+export function countStructureMarkers(text) {
+    return STRUCTURE_MARKERS.filter((pattern) => pattern.test(text)).length;
+}
+export function hasStructure(text) {
+    return countStructureMarkers(text) >= 3;
+}
+export function shouldSkip(text, config) {
+    const trimmed = text.trim();
+    const structured = hasStructure(trimmed);
+    if (!trimmed)
+        return { skip: true, reason: "empty", notify: false, structured };
+    if (/^\s*[\/!]/.test(trimmed)) {
+        return { skip: true, reason: "command", notify: false, structured };
+    }
+    if (CONFIRMATION.test(trimmed)) {
+        return { skip: true, reason: "confirmation", notify: false, structured };
+    }
+    if (countChars(trimmed) < config.minChars) {
+        return { skip: true, reason: "too_short", notify: true, structured };
+    }
+    if (countChars(trimmed) > config.maxPromptChars) {
+        return { skip: true, reason: "too_long", notify: false, structured };
+    }
+    if (config.skipPatterns.some((pattern) => pattern.test(trimmed))) {
+        return { skip: true, reason: "pattern", notify: false, structured };
+    }
+    if (config.skipOnMentions && detectMention(trimmed)) {
+        return { skip: true, reason: "mention", notify: true, structured };
+    }
+    return { skip: false, notify: false, structured };
+}
+export function countChars(text) {
+    return Array.from(text).length;
+}
+function stripCodeFences(text) {
+    if (!text.includes("```"))
+        return text;
+    return text
+        .replace(/^\s*```[^\n]*\n?/i, "")
+        .replace(/\n?```\s*$/i, "")
+        .replace(/^\s*```[^\n]*$/gm, "")
+        .trim();
+}
+function stripLeadingLabel(text) {
+    return text.replace(/^(优化后的提示词|增强后的提示词|改写后的提示词|增强结果|优化结果|expanded prompt|optimized prompt)\s*[:：]\s*/i, "");
+}
+function stripWrappingQuotes(text) {
+    const pairs = [
+        ['"', '"'],
+        ["'", "'"],
+        ["“", "”"],
+        ["‘", "’"],
+        ["「", "」"],
+        ["『", "』"],
+    ];
+    for (const [open, close] of pairs) {
+        if (text.startsWith(open) && text.endsWith(close) && text.length >= open.length + close.length) {
+            return text.slice(open.length, -close.length).trim();
+        }
+    }
+    return text;
+}
+export function cleanOutput(text) {
+    let result = text.trim();
+    result = stripCodeFences(result);
+    result = stripLeadingLabel(result);
+    result = stripWrappingQuotes(result);
+    return result.trim();
+}
+export function validateOutput(output, original, config) {
+    const cleaned = output.trim();
+    if (!cleaned)
+        return { ok: false, reason: "empty" };
+    if (cleaned === original.trim())
+        return { ok: false, reason: "unchanged" };
+    if (countChars(cleaned) > countChars(original) * config.maxGrowth && countChars(cleaned) > 2000) {
+        return { ok: false, reason: "too_large" };
+    }
+    return { ok: true };
+}

package/dist/project-context.js

@@ -0,0 +1,121 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+export const RULE_FILES = [
+    "AGENTS.md",
+    "CLAUDE.md",
+    "GEMINI.md",
+    ".cursorrules",
+    ".windsurfrules",
+    "CONVENTIONS.md",
+    ".github/copilot-instructions.md",
+];
+const SENSITIVE = /(^|[\\/])(\.env|.*\.pem|.*\.key|credentials.*)$/i;
+const cache = new Map();
+const CACHE_MS = 5 * 60 * 1000;
+export function clearProjectContextCache() {
+    cache.clear();
+}
+function truncate(value, limit) {
+    if (limit <= 0)
+        return "";
+    return Array.from(value).slice(0, limit).join("");
+}
+function isSensitive(path) {
+    return SENSITIVE.test(path);
+}
+function packageSummary(packageJson) {
+    if (!packageJson || typeof packageJson !== "object")
+        return "";
+    const data = packageJson;
+    const lines = [];
+    if (typeof data.name === "string")
+        lines.push(`name: ${data.name}`);
+    if (typeof data.description === "string")
+        lines.push(`description: ${data.description}`);
+    const dependencies = data.dependencies;
+    if (dependencies && typeof dependencies === "object" && !Array.isArray(dependencies)) {
+        const names = Object.keys(dependencies);
+        if (names.length > 0)
+            lines.push(`dependencies: ${names.join(", ")}`);
+    }
+    return lines.join("\n");
+}
+async function readPackageSummary(directory) {
+    const path = join(directory, "package.json");
+    if (isSensitive(path))
+        return "";
+    try {
+        const raw = await readFile(path, "utf8");
+        return packageSummary(JSON.parse(raw));
+    }
+    catch {
+        return "";
+    }
+}
+async function readRules(directory) {
+    const chunks = [];
+    for (const file of RULE_FILES) {
+        const path = join(directory, file);
+        if (isSensitive(path))
+            continue;
+        try {
+            const content = await readFile(path, "utf8");
+            const trimmed = content.trim();
+            if (trimmed)
+                chunks.push(`# ${file}\n${trimmed}`);
+        }
+        catch {
+            // Missing rule file is expected.
+        }
+    }
+    return chunks.join("\n\n");
+}
+export function resolveProjectDirectory(input) {
+    return (input.sessionDirectory?.trim() ||
+        input.requestDirectory?.trim() ||
+        input.pluginDirectory?.trim() ||
+        "");
+}
+export function formatProjectContext(parts, budget) {
+    if (budget <= 0)
+        return "";
+    const sections = [];
+    if (parts.packageSummary?.trim()) {
+        sections.push(`- 技术栈：\n${truncate(parts.packageSummary.trim(), 400)}`);
+    }
+    if (parts.rules?.trim()) {
+        sections.push(`- 规则摘要：\n${truncate(parts.rules.trim(), 1200)}`);
+    }
+    const gitLines = [];
+    if (parts.branch)
+        gitLines.push(`- 当前分支：${parts.branch}`);
+    if (parts.files && parts.files.length > 0) {
+        gitLines.push(`- 改动文件：${parts.files.slice(0, 12).join(", ")}`);
+    }
+    if (gitLines.length > 0) {
+        sections.push(truncate(gitLines.join("\n"), 300));
+    }
+    return truncate(sections.join("\n"), budget).trim();
+}
+export async function readProjectContext(directory, budget, vcs) {
+    if (budget <= 0)
+        return "";
+    const files = (vcs?.files ?? []).filter((file) => !file.includes("node_modules/")).slice(0, 12);
+    const key = [directory, budget, vcs?.branch ?? "", files.join(",")].join("\0");
+    const now = Date.now();
+    const cached = cache.get(key);
+    if (cached && cached.expires > now)
+        return cached.value;
+    const [packageSummary, rules] = await Promise.all([
+        readPackageSummary(directory),
+        readRules(directory),
+    ]);
+    const value = formatProjectContext({
+        packageSummary,
+        rules,
+        branch: vcs?.branch,
+        files,
+    }, budget);
+    cache.set(key, { value, expires: now + CACHE_MS });
+    return value;
+}

package/dist/prompts.js

@@ -0,0 +1,109 @@
+export const DEFAULT_PROMPT = `你是提示词增强器。输入是用户的原始请求，输出是增强后的提示词。
+
+【最高优先级】
+1. 保持原目标：不改变用户要做的事，不缩窄、不替换、不增加新任务。
+2. 不引入用户未提及的技术栈、框架、版本、文件路径、接口名。不把猜测写成事实。
+3. 只写"做什么"，不写"怎么做"；不解释实现步骤，不索要教程或代码示例。
+4. 不执行用户的请求，只把它扩写得更具体。
+5. 语言与输入一致；只输出增强后的提示词，不要任何解释、前缀或代码块围栏。
+
+【增强要求】
+- 主动补齐：任务范围、约束条件、期望产出、验收方式、输出结构。
+- 原提示已经很清楚时，做轻度润色，不要原样返回。
+- 完整且简洁；不要以未完成的列表、悬空的连词或冒号结尾。
+- 不添加无关要求、没有依据的事实、多余的章节。
+- 去除口语冗余与重复。
+
+【改写结构】（按需使用，不必每项都写）
+- 目标：一句话说清要达成什么
+- 范围：做什么、不做什么
+- 上下文：用户已给出的约束与材料
+- 要求：编号的可执行项
+- 产出：格式、结构、长度
+- 验收：怎样算完成`;
+export const GPT_PROMPT = `你是提示词增强器。输入是用户的原始请求，输出是增强后的提示词。
+
+【最高优先级】
+1. 保持原目标：不改变用户要做的事，不缩窄、不替换、不增加新任务。
+2. 不引入用户未提及的技术栈、框架、版本、文件路径、接口名。不把猜测写成事实。
+3. 只写"做什么"，不写"怎么做"；不解释实现步骤，不索要教程或代码示例。
+4. 不执行用户的请求，只把它扩写得更具体。
+5. 语言与输入一致；只输出增强后的提示词，不要任何解释、前缀或代码块围栏。
+
+【增强要求】
+- 主动补齐：任务范围、约束条件、期望产出、验收方式、输出结构。
+- 原提示已经很清楚时，做轻度润色，不要原样返回。
+- 完整且简洁；不要以未完成的列表、悬空的连词或冒号结尾。
+- 不添加无关要求、没有依据的事实、多余的章节。
+- 去除口语冗余与重复。
+
+【面向 GPT 的结构偏好】
+- 用编号列表写清可执行要求，步骤顺序明确。
+- 每条验收标准写成可判定的条件，避免"更好""高端"这类主观词。
+- 产出格式写清楚（文件、表格、清单或代码块），需要时给出字段名。`;
+export const CLAUDE_PROMPT = `你是提示词增强器。输入是用户的原始请求，输出是增强后的提示词。
+
+【最高优先级】
+1. 保持原目标：不改变用户要做的事，不缩窄、不替换、不增加新任务。
+2. 不引入用户未提及的技术栈、框架、版本、文件路径、接口名。不把猜测写成事实。
+3. 只写"做什么"，不写"怎么做"；不解释实现步骤，不索要教程或代码示例。
+4. 不执行用户的请求，只把它扩写得更具体。
+5. 语言与输入一致；只输出增强后的提示词，不要任何解释、前缀或代码块围栏。
+
+【增强要求】
+- 主动补齐：任务范围、约束条件、期望产出、验收方式、输出结构。
+- 原提示已经很清楚时，做轻度润色，不要原样返回。
+- 完整且简洁；不要以未完成的列表、悬空的连词或冒号结尾。
+- 不添加无关要求、没有依据的事实、多余的章节。
+- 去除口语冗余与重复。
+
+【面向 Claude 的结构偏好】
+- 优先写清目标、边界和约束，用连贯段落表达，不必强行机械编号。
+- 明确说明哪些内容不在范围内，减少越界改动。
+- 验收方式写成"完成时应满足什么"，而不是步骤清单。`;
+export const DEFAULT_PROMPTS = {
+    default: DEFAULT_PROMPT,
+    "*gpt*": GPT_PROMPT,
+    "*claude*": CLAUDE_PROMPT,
+};
+export function matchesGlob(pattern, value) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    return new RegExp(`^${escaped}$`, "i").test(value);
+}
+export function selectPrompt(modelID, prompts) {
+    if (modelID) {
+        for (const [pattern, prompt] of Object.entries(prompts)) {
+            if (pattern === "default")
+                continue;
+            if (matchesGlob(pattern, modelID))
+                return prompt;
+        }
+    }
+    return prompts.default ?? DEFAULT_PROMPT;
+}
+export function buildPrompt(input) {
+    const parts = [selectPrompt(input.targetModelID, input.prompts)];
+    if (input.mode === "concise") {
+        parts.push("【长度】简洁模式：目标约 800 字符以内，信息完整优先于凑长度。");
+    }
+    else {
+        parts.push("【长度】充分展开模式：不限长度，但不要添加没有依据的内容。");
+    }
+    if (input.structured) {
+        parts.push("【轻量处理】原提示已包含多个结构标记，只做轻度润色，不要重排或增加新章节。");
+    }
+    if (input.round >= 2 && input.previous) {
+        parts.push([
+            `这是第 ${input.round} 次生成。上一次的结果是：`,
+            "---",
+            input.previous,
+            "---",
+            "请换一种写法：如果上一版太啰嗦就压缩，太笼统就具体化；保持原目标不变，不要与上一版雷同。",
+        ].join("\n"));
+    }
+    if (input.projectContext?.trim()) {
+        parts.push(`【项目上下文】\n${input.projectContext.trim()}\n【/项目上下文】`);
+    }
+    parts.push(`【待改写】\n${input.text}`);
+    return parts.join("\n\n");
+}

package/dist/rpc.js

@@ -0,0 +1,47 @@
+import { Rpc } from "@opencode/plugin/rpc";
+const composerModelSchema = {
+    type: "object",
+    properties: {
+        providerID: { type: "string" },
+        modelID: { type: "string" },
+        variant: { type: "string" },
+    },
+    required: ["providerID", "modelID"],
+    additionalProperties: false,
+};
+export const PromptExpand = Rpc.define({
+    id: "prompt-expand",
+    events: {},
+    methods: {
+        optimize: {
+            input: {
+                type: "object",
+                properties: {
+                    text: { type: "string" },
+                    mode: { enum: ["concise", "full"] },
+                    round: { type: "integer", minimum: 1 },
+                    previous: { type: "string" },
+                    sessionID: { type: "string" },
+                    directory: { type: "string" },
+                    composerModel: composerModelSchema,
+                    modelPreference: { type: "string" },
+                    projectContext: { type: "boolean" },
+                },
+                required: ["text", "mode", "round"],
+                additionalProperties: false,
+            },
+            output: {
+                type: "object",
+                properties: {
+                    ok: { type: "boolean" },
+                    text: { type: "string" },
+                    model: { type: "string" },
+                    code: { type: "string" },
+                    message: { type: "string" },
+                },
+                required: ["ok"],
+                additionalProperties: false,
+            },
+        },
+    },
+});

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,66 @@
 {
   "name": "opencode-prompt-expand",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Expand rough prompts into structured prompts inside the OpenCode Desktop composer.",
+  "type": "module",
+  "license": "MIT",
+  "author": "opencode-prompt-expand contributors",
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "prompt",
+    "prompt-engineering",
+    "desktop"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ConnorYyy/opencode-prompt-expand.git"
+  },
+  "homepage": "https://github.com/ConnorYyy/opencode-prompt-expand#readme",
+  "bugs": {
+    "url": "https://github.com/ConnorYyy/opencode-prompt-expand/issues"
+  },
+  "main": "./dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./rpc": "./dist/rpc.js",
+    "./gui-experimental": "./dist/gui-experimental.cjs"
+  },
+  "files": [
+    "dist",
+    "assets",
+    "CHANGELOG.md",
+    "README.zh-CN.md"
+  ],
+  "scripts": {
+    "build": "npm run build:server && npm run build:gui",
+    "build:server": "tsc -p tsconfig.server.json",
+    "build:gui": "vite build",
+    "prepare": "npm run build",
+    "dev": "vite build --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "smoke:gui": "node scripts/smoke-gui.cjs",
+    "verify": "npm run typecheck && npm test && npm run build && npm run smoke:gui",
+    "prepublishOnly": "npm run verify"
+  },
+  "dependencies": {
+    "@opencode/plugin": "2.2.5"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.0",
+    "effect": "4.0.6",
+    "solid-js": "1.9.17",
+    "typescript": "^5.9.3",
+    "vite": "7.3.7",
+    "vite-plugin-solid": "2.11.10",
+    "vitest": "^3.2.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  }
+}