@royalcat/opencode-dcp-rc 0.0.0-stage → 4.0.0

package/lib/prompts/store.ts

@@ -0,0 +1,452 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, statSync } from "fs"
+import { join, dirname } from "path"
+import { homedir } from "os"
+import type { Logger } from "../logger"
+import { systemPrompt } from "./system"
+import { rcPrompt } from "./compress-rc"
+import type { IdFormat } from "../message-ids"
+import { CONTEXT_LIMIT_NUDGE } from "./context-limit-nudge"
+import { TURN_NUDGE } from "./turn-nudge"
+import { ITERATION_NUDGE } from "./iteration-nudge"
+import { MANUAL_MODE_SYSTEM_EXTENSION, SUBAGENT_SYSTEM_EXTENSION } from "./extensions/system"
+
+export type PromptKey =
+    | "system"
+    | "compress-rc"
+    | "context-limit-nudge"
+    | "turn-nudge"
+    | "iteration-nudge"
+
+type EditablePromptField =
+    | "system"
+    | "compressRc"
+    | "contextLimitNudge"
+    | "turnNudge"
+    | "iterationNudge"
+
+interface PromptDefinition {
+    key: PromptKey
+    fileName: string
+    label: string
+    description: string
+    usage: string
+    runtimeField: EditablePromptField
+}
+
+interface PromptOverrideCandidate {
+    path: string
+}
+
+interface PromptPaths {
+    defaultsDir: string
+    globalOverridesDir: string
+    configDirOverridesDir: string | null
+    projectOverridesDir: string | null
+}
+
+export interface RuntimePrompts {
+    system: string
+    compressRc: string
+    contextLimitNudge: string
+    turnNudge: string
+    iterationNudge: string
+    manualExtension: string
+    subagentExtension: string
+}
+
+const PROMPT_DEFINITIONS: PromptDefinition[] = [
+    {
+        key: "system",
+        fileName: "system.md",
+        label: "System",
+        description: "Core system-level DCP instruction block",
+        usage: "Injected into the model system prompt on every request",
+        runtimeField: "system",
+    },
+    {
+        key: "compress-rc",
+        fileName: "compress-rc.md",
+        label: "Compress RC",
+        description: "rc-mode compress tool instructions (model selects IDs only)",
+        usage: "Registered as the rc-mode compress tool description",
+        runtimeField: "compressRc",
+    },
+    {
+        key: "context-limit-nudge",
+        fileName: "context-limit-nudge.md",
+        label: "Context Limit Nudge",
+        description: "High-priority nudge when context is over max threshold",
+        usage: "Injected when context usage is beyond configured max limits",
+        runtimeField: "contextLimitNudge",
+    },
+    {
+        key: "turn-nudge",
+        fileName: "turn-nudge.md",
+        label: "Turn Nudge",
+        description: "Nudge to compress closed ranges at turn boundaries",
+        usage: "Injected when context is between min and max limits at a new user turn",
+        runtimeField: "turnNudge",
+    },
+    {
+        key: "iteration-nudge",
+        fileName: "iteration-nudge.md",
+        label: "Iteration Nudge",
+        description: "Nudge after many iterations without user input",
+        usage: "Injected when iteration threshold is crossed",
+        runtimeField: "iterationNudge",
+    },
+]
+
+export const PROMPT_KEYS: PromptKey[] = [
+    "system",
+    "compress-rc",
+    "context-limit-nudge",
+    "turn-nudge",
+    "iteration-nudge",
+]
+
+const HTML_COMMENT_REGEX = /<!--[\s\S]*?-->/g
+const LEGACY_INLINE_COMMENT_LINE_REGEX = /^[ \t]*\/\/.*?\/\/[ \t]*$/gm
+const DCP_SYSTEM_REMINDER_TAG_REGEX =
+    /^\s*<dcp-system-reminder\b[^>]*>[\s\S]*<\/dcp-system-reminder>\s*$/i
+const DEFAULTS_README_FILE = "README.md"
+
+function bundledPrompts(format: IdFormat): Record<EditablePromptField, string> {
+    return {
+        system: systemPrompt(format),
+        compressRc: rcPrompt(format),
+        contextLimitNudge: CONTEXT_LIMIT_NUDGE,
+        turnNudge: TURN_NUDGE,
+        iterationNudge: ITERATION_NUDGE,
+    }
+}
+
+const INTERNAL_PROMPT_EXTENSIONS = {
+    manualExtension: MANUAL_MODE_SYSTEM_EXTENSION,
+    subagentExtension: SUBAGENT_SYSTEM_EXTENSION,
+}
+
+function createBundledRuntimePrompts(bundled: Record<EditablePromptField, string>): RuntimePrompts {
+    return {
+        ...bundled,
+        manualExtension: INTERNAL_PROMPT_EXTENSIONS.manualExtension,
+        subagentExtension: INTERNAL_PROMPT_EXTENSIONS.subagentExtension,
+    }
+}
+
+function findOpencodeDir(startDir: string): string | null {
+    let current = startDir
+    while (current !== "/") {
+        const candidate = join(current, ".opencode")
+        if (existsSync(candidate)) {
+            try {
+                if (statSync(candidate).isDirectory()) {
+                    return candidate
+                }
+            } catch {
+                // ignore inaccessible entries while walking upward
+            }
+        }
+        const parent = dirname(current)
+        if (parent === current) {
+            break
+        }
+        current = parent
+    }
+    return null
+}
+
+function resolvePromptPaths(workingDirectory: string): PromptPaths {
+    const configHome = process.env.XDG_CONFIG_HOME || join(homedir(), ".config")
+    const globalRoot = join(configHome, "opencode", "dcp-prompts")
+    const defaultsDir = join(globalRoot, "defaults")
+    const globalOverridesDir = join(globalRoot, "overrides")
+
+    const configDirOverridesDir = process.env.OPENCODE_CONFIG_DIR
+        ? join(process.env.OPENCODE_CONFIG_DIR, "dcp-prompts", "overrides")
+        : null
+
+    const opencodeDir = findOpencodeDir(workingDirectory)
+    const projectOverridesDir = opencodeDir ? join(opencodeDir, "dcp-prompts", "overrides") : null
+
+    return {
+        defaultsDir,
+        globalOverridesDir,
+        configDirOverridesDir,
+        projectOverridesDir,
+    }
+}
+
+function stripConditionalTag(content: string, tagName: string): string {
+    const regex = new RegExp(`<${tagName}>[\\s\\S]*?<\/${tagName}>`, "gi")
+    return content.replace(regex, "")
+}
+
+function unwrapDcpTagIfWrapped(content: string): string {
+    const trimmed = content.trim()
+
+    if (DCP_SYSTEM_REMINDER_TAG_REGEX.test(trimmed)) {
+        return trimmed
+            .replace(/^\s*<dcp-system-reminder\b[^>]*>\s*/i, "")
+            .replace(/\s*<\/dcp-system-reminder>\s*$/i, "")
+            .trim()
+    }
+
+    return trimmed
+}
+
+function normalizeReminderPromptContent(content: string): string {
+    const normalized = content.trim()
+
+    if (!normalized) {
+        return ""
+    }
+
+    const startsWrapped = /^\s*<dcp-system-reminder\b[^>]*>/i.test(normalized)
+    const endsWrapped = /<\/dcp-system-reminder>\s*$/i.test(normalized)
+
+    if (startsWrapped !== endsWrapped) {
+        return ""
+    }
+
+    return unwrapDcpTagIfWrapped(normalized)
+}
+
+function stripPromptComments(content: string): string {
+    return content
+        .replace(/^\uFEFF/, "")
+        .replace(/\r\n?/g, "\n")
+        .replace(HTML_COMMENT_REGEX, "")
+        .replace(LEGACY_INLINE_COMMENT_LINE_REGEX, "")
+}
+
+function toEditablePromptText(definition: PromptDefinition, rawContent: string): string {
+    let normalized = stripPromptComments(rawContent).trim()
+    if (!normalized) {
+        return ""
+    }
+
+    if (definition.key === "system") {
+        normalized = stripConditionalTag(normalized, "manual")
+        normalized = stripConditionalTag(normalized, "subagent")
+    }
+
+    normalized = normalizeReminderPromptContent(normalized)
+
+    return normalized.trim()
+}
+
+function wrapRuntimePromptContent(definition: PromptDefinition, editableText: string): string {
+    const trimmed = editableText.trim()
+    if (!trimmed) {
+        return ""
+    }
+
+    return `<dcp-system-reminder>\n${trimmed}\n</dcp-system-reminder>`
+}
+
+function buildDefaultPromptFileContent(bundledEditableText: string): string {
+    return `${bundledEditableText.trim()}\n`
+}
+
+function buildDefaultsReadmeContent(): string {
+    const lines: string[] = []
+    lines.push("# DCP Prompt Defaults")
+    lines.push("")
+    lines.push("This directory stores the DCP prompts.")
+    lines.push("Each prompt file here should contain plain text only (no XML wrappers).")
+    lines.push("")
+    lines.push("## Creating Overrides")
+    lines.push("")
+    lines.push(
+        "1. Copy a prompt file from this directory into an overrides directory using the same filename.",
+    )
+    lines.push("2. Edit the copied file using plain text.")
+    lines.push("3. Restart OpenCode.")
+    lines.push("")
+    lines.push("To reset an override, delete the matching file from your overrides directory.")
+    lines.push("")
+    lines.push(
+        "Do not edit the default prompt files directly, they are just for reference, only files in the overrides directory are used.",
+    )
+    lines.push("")
+    lines.push("Override precedence (highest first):")
+    lines.push("1. `.opencode/dcp-prompts/overrides/` (project)")
+    lines.push("2. `$OPENCODE_CONFIG_DIR/dcp-prompts/overrides/` (config dir)")
+    lines.push("3. `~/.config/opencode/dcp-prompts/overrides/` (global)")
+    lines.push("")
+    lines.push("## Prompt Files")
+    lines.push("")
+
+    for (const definition of PROMPT_DEFINITIONS) {
+        lines.push(`- \`${definition.fileName}\``)
+        lines.push(`  - Purpose: ${definition.description}.`)
+        lines.push(`  - Runtime use: ${definition.usage}.`)
+    }
+
+    return `${lines.join("\n")}\n`
+}
+
+function readFileIfExists(filePath: string): string | null {
+    if (!existsSync(filePath)) {
+        return null
+    }
+
+    try {
+        return readFileSync(filePath, "utf-8")
+    } catch {
+        return null
+    }
+}
+
+export class PromptStore {
+    private readonly logger: Logger
+    private readonly paths: PromptPaths
+    private readonly customPromptsEnabled: boolean
+    private runtimePrompts: RuntimePrompts
+    private readonly bundled: Record<EditablePromptField, string>
+
+    constructor(
+        logger: Logger,
+        workingDirectory: string,
+        customPromptsEnabled = false,
+        idFormat: IdFormat = "xml",
+    ) {
+        this.logger = logger
+        this.paths = resolvePromptPaths(workingDirectory)
+        this.customPromptsEnabled = customPromptsEnabled
+        this.bundled = bundledPrompts(idFormat)
+        this.runtimePrompts = createBundledRuntimePrompts(this.bundled)
+
+        if (this.customPromptsEnabled) {
+            this.ensureDefaultFiles()
+        }
+        this.reload()
+    }
+
+    getRuntimePrompts(): RuntimePrompts {
+        return { ...this.runtimePrompts }
+    }
+
+    reload(): void {
+        const nextPrompts = createBundledRuntimePrompts(this.bundled)
+
+        if (!this.customPromptsEnabled) {
+            this.runtimePrompts = nextPrompts
+            return
+        }
+
+        for (const definition of PROMPT_DEFINITIONS) {
+            const bundledSource = this.bundled[definition.runtimeField]
+            const bundledEditable = toEditablePromptText(definition, bundledSource)
+            const bundledRuntime = wrapRuntimePromptContent(definition, bundledEditable)
+            const fallbackValue = bundledRuntime || bundledSource.trim()
+            let effectiveValue = fallbackValue
+
+            for (const candidate of this.getOverrideCandidates(definition.fileName)) {
+                const rawOverride = readFileIfExists(candidate.path)
+                if (rawOverride === null) {
+                    continue
+                }
+
+                const editableOverride = toEditablePromptText(definition, rawOverride)
+                if (!editableOverride) {
+                    this.logger.warn("Prompt override is empty or invalid after normalization", {
+                        key: definition.key,
+                        path: candidate.path,
+                    })
+                    continue
+                }
+
+                const wrappedOverride = wrapRuntimePromptContent(definition, editableOverride)
+                if (!wrappedOverride) {
+                    this.logger.warn("Prompt override could not be wrapped for runtime", {
+                        key: definition.key,
+                        path: candidate.path,
+                    })
+                    continue
+                }
+
+                effectiveValue = wrappedOverride
+                break
+            }
+
+            nextPrompts[definition.runtimeField] = effectiveValue
+        }
+
+        this.runtimePrompts = nextPrompts
+    }
+
+    private getOverrideCandidates(fileName: string): PromptOverrideCandidate[] {
+        const candidates: PromptOverrideCandidate[] = []
+
+        if (this.paths.projectOverridesDir) {
+            candidates.push({
+                path: join(this.paths.projectOverridesDir, fileName),
+            })
+        }
+
+        if (this.paths.configDirOverridesDir) {
+            candidates.push({
+                path: join(this.paths.configDirOverridesDir, fileName),
+            })
+        }
+
+        candidates.push({
+            path: join(this.paths.globalOverridesDir, fileName),
+        })
+
+        return candidates
+    }
+
+    private ensureDefaultFiles(): void {
+        try {
+            mkdirSync(this.paths.defaultsDir, { recursive: true })
+            mkdirSync(this.paths.globalOverridesDir, { recursive: true })
+        } catch {
+            this.logger.warn("Failed to initialize prompt directories", {
+                defaultsDir: this.paths.defaultsDir,
+                globalOverridesDir: this.paths.globalOverridesDir,
+            })
+            return
+        }
+
+        for (const definition of PROMPT_DEFINITIONS) {
+            const bundledEditable = toEditablePromptText(
+                definition,
+                this.bundled[definition.runtimeField],
+            )
+            const managedContent = buildDefaultPromptFileContent(
+                bundledEditable || this.bundled[definition.runtimeField],
+            )
+            const filePath = join(this.paths.defaultsDir, definition.fileName)
+
+            try {
+                const existing = readFileIfExists(filePath)
+                if (existing === managedContent) {
+                    continue
+                }
+                writeFileSync(filePath, managedContent, "utf-8")
+            } catch {
+                this.logger.warn("Failed to write default prompt file", {
+                    key: definition.key,
+                    path: filePath,
+                })
+            }
+        }
+
+        const readmePath = join(this.paths.defaultsDir, DEFAULTS_README_FILE)
+        const readmeContent = buildDefaultsReadmeContent()
+
+        try {
+            const existing = readFileIfExists(readmePath)
+            if (existing !== readmeContent) {
+                writeFileSync(readmePath, readmeContent, "utf-8")
+            }
+        } catch {
+            this.logger.warn("Failed to write defaults README", {
+                path: readmePath,
+            })
+        }
+    }
+}

package/lib/prompts/system.ts

@@ -0,0 +1,41 @@
+import type { IdFormat } from "../message-ids"
+
+export function systemPrompt(format: IdFormat = "xml"): string {
+    const markers =
+        format === "compact" ? "`@4@`, `@b1@`, `@blocked@`, priority labels" : "`<dcp-message-id>`"
+    return `
+You operate in a context-constrained environment. Manage context continuously to avoid buildup and preserve retrieval quality. Efficient context management is paramount for your agentic performance.
+
+The ONLY tool you have for context management is \`compress\`. It replaces older conversation content with compact technical summaries.
+
+${markers} and \`<dcp-system-reminder>\` tags are environment-injected metadata. Do not output them.
+
+THE PHILOSOPHY OF COMPRESS
+\`compress\` transforms conversation content into dense, high-fidelity summaries. This is not cleanup - it is crystallization. Your summary becomes the authoritative record of what transpired.
+
+Think of compression as phase transitions: raw exploration becomes refined understanding. The original context served its purpose; your summary now carries that understanding forward.
+
+COMPRESS WHEN
+
+A section is genuinely closed and the raw conversation has served its purpose:
+
+- Research concluded and findings are clear
+- Implementation finished and verified
+- Exploration exhausted and patterns understood
+- Dead-end noise can be discarded without waiting for a whole chapter to close
+
+DO NOT COMPRESS IF
+
+- Raw context is still relevant and needed for edits or precise references
+- The target content is still actively in progress
+- You may need exact code, error messages, or file contents in the immediate next steps
+
+Before compressing, ask: _"Is this section closed enough to become summary-only right now?"_
+
+Evaluate conversation signal-to-noise REGULARLY. Use \`compress\` deliberately with quality-first summaries. Prioritize stale content intelligently to maintain a high-signal context window that supports your agency.
+
+It is of your responsibility to keep a sharp, high-quality context window for optimal performance.
+`
+}
+
+export const SYSTEM = systemPrompt()

package/lib/prompts/turn-nudge.ts

@@ -0,0 +1,10 @@
+export const TURN_NUDGE = `<dcp-system-reminder>
+Evaluate the conversation for compressible ranges.
+
+If any messages are cleanly closed and unlikely to be needed again, use the compress tool on them.
+If direction has shifted, compress earlier ranges that are now less relevant.
+
+The goal is to filter noise and distill key information so context accumulation stays under control.
+Keep active context uncompressed.
+</dcp-system-reminder>
+`

package/lib/protected-patterns.ts

@@ -0,0 +1,159 @@
+function normalizePath(input: string): string {
+    // A single backslash. In source, "\\" is the one-character string; the
+    // previous "\\\\" was a *two*-character string, so it only ever matched a
+    // doubled separator -- which a real Windows path does not contain. The
+    // normalisation was therefore a no-op on the only platform that needs it.
+    return input.replaceAll("\\", "/")
+}
+
+function escapeRegExpChar(ch: string): string {
+    return /[\\.^$+{}()|\[\]]/.test(ch) ? `\\${ch}` : ch
+}
+
+export function matchesGlob(inputPath: string, pattern: string): boolean {
+    if (!pattern) return false
+
+    const input = normalizePath(inputPath)
+    const pat = normalizePath(pattern)
+
+    let regex = "^"
+
+    for (let i = 0; i < pat.length; i++) {
+        const ch = pat[i]
+
+        if (ch === "*") {
+            const next = pat[i + 1]
+            if (next === "*") {
+                const after = pat[i + 2]
+                if (after === "/") {
+                    // **/  (zero or more directories)
+                    regex += "(?:.*/)?"
+                    i += 2
+                    continue
+                }
+
+                // **
+                regex += ".*"
+                i++
+                continue
+            }
+
+            // *
+            regex += "[^/]*"
+            continue
+        }
+
+        if (ch === "?") {
+            regex += "[^/]"
+            continue
+        }
+
+        if (ch === "/") {
+            regex += "/"
+            continue
+        }
+
+        regex += escapeRegExpChar(ch)
+    }
+
+    regex += "$"
+
+    return new RegExp(regex).test(input)
+}
+
+export function getFilePathsFromParameters(tool: string, parameters: unknown): string[] {
+    if (typeof parameters !== "object" || parameters === null) {
+        return []
+    }
+
+    const paths: string[] = []
+    const params = parameters as Record<string, any>
+
+    // 1. apply_patch uses patchText with embedded paths
+    if ((tool === "apply_patch" || tool === "patch") && typeof params.patchText === "string") {
+        const pathRegex = /\*\*\* (?:Add|Delete|Update) File: ([^\n\r]+)/g
+        let match
+        while ((match = pathRegex.exec(params.patchText)) !== null) {
+            paths.push(match[1].trim())
+        }
+    }
+
+    // 2. multiedit uses top-level filePath and nested edits array
+    if (tool === "multiedit") {
+        if (typeof params.filePath === "string") {
+            paths.push(params.filePath)
+        }
+        if (Array.isArray(params.edits)) {
+            for (const edit of params.edits) {
+                if (edit && typeof edit.filePath === "string") {
+                    paths.push(edit.filePath)
+                }
+            }
+        }
+    }
+
+    // 3. Default check for common filePath parameter (read, write, edit, etc)
+    if (typeof params.filePath === "string") {
+        paths.push(params.filePath)
+    }
+
+    // V2 file tools use path rather than filePath.
+    if (["read", "write", "edit"].includes(tool) && typeof params.path === "string") {
+        paths.push(params.path)
+    }
+
+    // Return unique non-empty paths
+    return [...new Set(paths)].filter((p) => p.length > 0)
+}
+
+export function isFilePathProtected(filePaths: string[], patterns: string[]): boolean {
+    if (!filePaths || filePaths.length === 0) return false
+    if (!patterns || patterns.length === 0) return false
+
+    return filePaths.some((path) => patterns.some((pattern) => matchesGlob(path, pattern)))
+}
+
+const GLOB_CHARS = /[*?]/
+
+export function isToolNameProtected(toolName: string, patterns: string[]): boolean {
+    if (!toolName || !patterns || patterns.length === 0) return false
+
+    const exactPatterns: Set<string> = new Set()
+    const globPatterns: string[] = []
+
+    for (const pattern of patterns) {
+        if (GLOB_CHARS.test(pattern)) {
+            globPatterns.push(pattern)
+        } else {
+            exactPatterns.add(pattern)
+        }
+    }
+
+    if (exactPatterns.has(toolName)) {
+        return true
+    }
+
+    return globPatterns.some((pattern) => matchesGlob(toolName, pattern))
+}
+
+export function isToolProtected(
+    tool: string,
+    input: unknown,
+    tools: string[],
+    files: string[],
+    metadata?: Record<string, unknown>,
+): boolean {
+    const calls = [{ tool, input }]
+    // V2 Code Mode keeps nested inputs, but only one combined output. Protect
+    // that output as a whole when any nested call matches the user's rules.
+    if (tool === "execute" && Array.isArray(metadata?.toolCalls)) {
+        for (const call of metadata.toolCalls) {
+            if (call && typeof call.tool === "string") calls.push(call)
+        }
+    }
+    return calls.some(
+        (call) =>
+            isToolNameProtected(call.tool, tools) ||
+            isFilePathProtected(getFilePathsFromParameters(call.tool, call.input), files),
+    )
+}

package/lib/state/index.ts

@@ -0,0 +1,4 @@
+export * from "./persistence"
+export * from "./types"
+export * from "./state"
+export * from "./tool-cache"