@xortex/xcode 3.0.0

package/package.json

@@ -0,0 +1,120 @@
+{
+  "name": "@xortex/xcode",
+  "version": "3.0.0",
+  "description": "XCode - AI-powered coding assistant with XMem long-term memory. Supports Claude, Gemini, Kimi, DeepSeek via OpenRouter.",
+  "main": "main.tsx",
+  "bin": {
+    "xcode": "./bin/xcode"
+  },
+  "scripts": {
+    "start": "bun run ./entrypoints/cli.tsx || npx tsx ./entrypoints/cli.tsx",
+    "install-global": "npm install -g ."
+  },
+  "files": [
+    "bin/",
+    "entrypoints/",
+    "main.tsx",
+    "src/",
+    "constants/",
+    "utils/",
+    "services/",
+    "tools/",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "ai",
+    "coding",
+    "assistant",
+    "claude",
+    "gemini",
+    "kimi",
+    "deepseek",
+    "openrouter",
+    "memory",
+    "xmem",
+    "cli",
+    "terminal"
+  ],
+  "author": "XortexAI",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/XortexAI/XCode.git"
+  },
+  "bugs": {
+    "url": "https://github.com/XortexAI/XCode/issues"
+  },
+  "homepage": "https://github.com/XortexAI/XCode#readme",
+  "dependencies": {
+    "@anthropic-ai/sandbox-runtime": "^0.0.46",
+    "@anthropic-ai/sdk": "^0.81.0",
+    "@commander-js/extra-typings": "^14.0.0",
+    "@google/generative-ai": "^0.24.1",
+    "@growthbook/growthbook": "^1.6.5",
+    "@hono/node-server": "^1.19.12",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@opentelemetry/resources": "^2.6.1",
+    "@opentelemetry/sdk-logs": "^0.214.0",
+    "ansi-escapes": "^7.3.0",
+    "bidi-js": "^1.0.3",
+    "chalk": "^5.6.2",
+    "chalk-template": "^1.1.2",
+    "chokidar": "^5.0.0",
+    "cli-boxes": "^4.0.1",
+    "color-diff-napi": "^0.0.1",
+    "date-fns": "^4.1.0",
+    "diff": "^8.0.4",
+    "dotenv": "^17.3.1",
+    "draftlog": "^1.0.13",
+    "emoji-regex": "^10.6.0",
+    "env-paths": "^4.0.0",
+    "execa": "^9.6.1",
+    "express": "^5.2.1",
+    "fuse.js": "^7.1.0",
+    "get-east-asian-width": "^1.5.0",
+    "glob": "^13.0.6",
+    "hono": "^4.12.9",
+    "https-proxy-agent": "^9.0.0",
+    "ignore": "^7.0.5",
+    "ink": "^6.8.0",
+    "is-interactive": "^2.0.0",
+    "is-unicode-supported": "^2.1.0",
+    "jsonc-parser": "^3.3.1",
+    "lodash-es": "^4.17.23",
+    "log-update": "^7.2.0",
+    "lru-cache": "^11.2.7",
+    "marked": "^17.0.5",
+    "node-fetch": "^3.3.2",
+    "open": "^11.0.0",
+    "open-editor": "^6.0.0",
+    "p-map": "^7.0.4",
+    "picomatch": "^4.0.4",
+    "qrcode": "^1.5.4",
+    "react": "^19.2.4",
+    "readline-sync": "^1.4.10",
+    "redaxios": "^0.5.1",
+    "semver": "^7.7.4",
+    "slice-ansi": "^8.0.0",
+    "string-width": "^8.2.0",
+    "strip-ansi": "^7.2.0",
+    "term-size": "^3.0.2",
+    "terminal-link": "^5.0.0",
+    "terminal-size": "^4.0.1",
+    "tree-kill": "^1.2.2",
+    "usehooks-ts": "^3.1.1",
+    "uuid": "^13.0.0",
+    "widest-line": "^6.0.0",
+    "ws": "^8.20.0",
+    "xmem-ai": "^1.0.0",
+    "xss": "^1.0.15",
+    "yaml": "^2.8.3",
+    "yaml-ast-parser": "^0.0.43",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "^25.5.0",
+    "@types/react": "^19.2.14"
+  }
+}

package/services/AgentSummary/agentSummary.ts

@@ -0,0 +1,179 @@
+/**
+ * Periodic background summarization for coordinator mode sub-agents.
+ *
+ * Forks the sub-agent's conversation every ~30s using runForkedAgent()
+ * to generate a 1-2 sentence progress summary. The summary is stored
+ * on AgentProgress for UI display.
+ *
+ * Cache sharing: uses the same CacheSafeParams as the parent agent
+ * to share the prompt cache. Tools are kept in the request for cache
+ * key matching but denied via canUseTool callback.
+ */
+
+import type { TaskContext } from '../../Task.js'
+import { updateAgentSummary } from '../../tasks/LocalAgentTask/LocalAgentTask.js'
+import { filterIncompleteToolCalls } from '../../tools/AgentTool/runAgent.js'
+import type { AgentId } from '../../types/ids.js'
+import { logForDebugging } from '../../utils/debug.js'
+import {
+  type CacheSafeParams,
+  runForkedAgent,
+} from '../../utils/forkedAgent.js'
+import { logError } from '../../utils/log.js'
+import { createUserMessage } from '../../utils/messages.js'
+import { getAgentTranscript } from '../../utils/sessionStorage.js'
+
+const SUMMARY_INTERVAL_MS = 30_000
+
+function buildSummaryPrompt(previousSummary: string | null): string {
+  const prevLine = previousSummary
+    ? `\nPrevious: "${previousSummary}" — say something NEW.\n`
+    : ''
+
+  return `Describe your most recent action in 3-5 words using present tense (-ing). Name the file or function, not the branch. Do not use tools.
+${prevLine}
+Good: "Reading runAgent.ts"
+Good: "Fixing null check in validate.ts"
+Good: "Running auth module tests"
+Good: "Adding retry logic to fetchUser"
+
+Bad (past tense): "Analyzed the branch diff"
+Bad (too vague): "Investigating the issue"
+Bad (too long): "Reviewing full branch diff and AgentTool.tsx integration"
+Bad (branch name): "Analyzed adam/background-summary branch diff"`
+}
+
+export function startAgentSummarization(
+  taskId: string,
+  agentId: AgentId,
+  cacheSafeParams: CacheSafeParams,
+  setAppState: TaskContext['setAppState'],
+): { stop: () => void } {
+  // Drop forkContextMessages from the closure — runSummary rebuilds it each
+  // tick from getAgentTranscript(). Without this, the original fork messages
+  // (passed from AgentTool.tsx) are pinned for the lifetime of the timer.
+  const { forkContextMessages: _drop, ...baseParams } = cacheSafeParams
+  let summaryAbortController: AbortController | null = null
+  let timeoutId: ReturnType<typeof setTimeout> | null = null
+  let stopped = false
+  let previousSummary: string | null = null
+
+  async function runSummary(): Promise<void> {
+    if (stopped) return
+
+    logForDebugging(`[AgentSummary] Timer fired for agent ${agentId}`)
+
+    try {
+      // Read current messages from transcript
+      const transcript = await getAgentTranscript(agentId)
+      if (!transcript || transcript.messages.length < 3) {
+        // Not enough context yet — finally block will schedule next attempt
+        logForDebugging(
+          `[AgentSummary] Skipping summary for ${taskId}: not enough messages (${transcript?.messages.length ?? 0})`,
+        )
+        return
+      }
+
+      // Filter to clean message state
+      const cleanMessages = filterIncompleteToolCalls(transcript.messages)
+
+      // Build fork params with current messages
+      const forkParams: CacheSafeParams = {
+        ...baseParams,
+        forkContextMessages: cleanMessages,
+      }
+
+      logForDebugging(
+        `[AgentSummary] Forking for summary, ${cleanMessages.length} messages in context`,
+      )
+
+      // Create abort controller for this summary
+      summaryAbortController = new AbortController()
+
+      // Deny tools via callback, NOT by passing tools:[] - that busts cache
+      const canUseTool = async () => ({
+        behavior: 'deny' as const,
+        message: 'No tools needed for summary',
+        decisionReason: { type: 'other' as const, reason: 'summary only' },
+      })
+
+      // DO NOT set maxOutputTokens here. The fork piggybacks on the main
+      // thread's prompt cache by sending identical cache-key params (system,
+      // tools, model, messages prefix, thinking config). Setting maxOutputTokens
+      // would clamp budget_tokens, creating a thinking config mismatch that
+      // invalidates the cache.
+      //
+      // ContentReplacementState is cloned by default in createSubagentContext
+      // from forkParams.toolUseContext (the subagent's LIVE state captured at
+      // onCacheSafeParams time). No explicit override needed.
+      const result = await runForkedAgent({
+        promptMessages: [
+          createUserMessage({ content: buildSummaryPrompt(previousSummary) }),
+        ],
+        cacheSafeParams: forkParams,
+        canUseTool,
+        querySource: 'agent_summary',
+        forkLabel: 'agent_summary',
+        overrides: { abortController: summaryAbortController },
+        skipTranscript: true,
+      })
+
+      if (stopped) return
+
+      // Extract summary text from result
+      for (const msg of result.messages) {
+        if (msg.type !== 'assistant') continue
+        // Skip API error messages
+        if (msg.isApiErrorMessage) {
+          logForDebugging(
+            `[AgentSummary] Skipping API error message for ${taskId}`,
+          )
+          continue
+        }
+        const textBlock = msg.message.content.find(b => b.type === 'text')
+        if (textBlock?.type === 'text' && textBlock.text.trim()) {
+          const summaryText = textBlock.text.trim()
+          logForDebugging(
+            `[AgentSummary] Summary result for ${taskId}: ${summaryText}`,
+          )
+          previousSummary = summaryText
+          updateAgentSummary(taskId, summaryText, setAppState)
+          break
+        }
+      }
+    } catch (e) {
+      if (!stopped && e instanceof Error) {
+        logError(e)
+      }
+    } finally {
+      summaryAbortController = null
+      // Reset timer on completion (not initiation) to prevent overlapping summaries
+      if (!stopped) {
+        scheduleNext()
+      }
+    }
+  }
+
+  function scheduleNext(): void {
+    if (stopped) return
+    timeoutId = setTimeout(runSummary, SUMMARY_INTERVAL_MS)
+  }
+
+  function stop(): void {
+    logForDebugging(`[AgentSummary] Stopping summarization for ${taskId}`)
+    stopped = true
+    if (timeoutId) {
+      clearTimeout(timeoutId)
+      timeoutId = null
+    }
+    if (summaryAbortController) {
+      summaryAbortController.abort()
+      summaryAbortController = null
+    }
+  }
+
+  // Start the first timer
+  scheduleNext()
+
+  return { stop }
+}

package/services/MagicDocs/magicDocs.ts

@@ -0,0 +1,254 @@
+/**
+ * Magic Docs automatically maintains markdown documentation files marked with special headers.
+ * When a file with "# MAGIC DOC: [title]" is read, it runs periodically in the background
+ * using a forked subagent to update the document with new learnings from the conversation.
+ *
+ * See docs/magic-docs.md for more information.
+ */
+
+import type { Tool, ToolUseContext } from '../../Tool.js'
+import type { BuiltInAgentDefinition } from '../../tools/AgentTool/loadAgentsDir.js'
+import { runAgent } from '../../tools/AgentTool/runAgent.js'
+import { FILE_EDIT_TOOL_NAME } from '../../tools/FileEditTool/constants.js'
+import {
+  FileReadTool,
+  type Output as FileReadToolOutput,
+  registerFileReadListener,
+} from '../../tools/FileReadTool/FileReadTool.js'
+import { isFsInaccessible } from '../../utils/errors.js'
+import { cloneFileStateCache } from '../../utils/fileStateCache.js'
+import {
+  type REPLHookContext,
+  registerPostSamplingHook,
+} from '../../utils/hooks/postSamplingHooks.js'
+import {
+  createUserMessage,
+  hasToolCallsInLastAssistantTurn,
+} from '../../utils/messages.js'
+import { sequential } from '../../utils/sequential.js'
+import { buildMagicDocsUpdatePrompt } from './prompts.js'
+
+// Magic Doc header pattern: # MAGIC DOC: [title]
+// Matches at the start of the file (first line)
+const MAGIC_DOC_HEADER_PATTERN = /^#\s*MAGIC\s+DOC:\s*(.+)$/im
+// Pattern to match italics on the line immediately after the header
+const ITALICS_PATTERN = /^[_*](.+?)[_*]\s*$/m
+
+// Track magic docs
+type MagicDocInfo = {
+  path: string
+}
+
+const trackedMagicDocs = new Map<string, MagicDocInfo>()
+
+export function clearTrackedMagicDocs(): void {
+  trackedMagicDocs.clear()
+}
+
+/**
+ * Detect if a file content contains a Magic Doc header
+ * Returns an object with title and optional instructions, or null if not a magic doc
+ */
+export function detectMagicDocHeader(
+  content: string,
+): { title: string; instructions?: string } | null {
+  const match = content.match(MAGIC_DOC_HEADER_PATTERN)
+  if (!match || !match[1]) {
+    return null
+  }
+
+  const title = match[1].trim()
+
+  // Look for italics on the next line after the header (allow one optional blank line)
+  const headerEndIndex = match.index! + match[0].length
+  const afterHeader = content.slice(headerEndIndex)
+  // Match: newline, optional blank line, then content line
+  const nextLineMatch = afterHeader.match(/^\s*\n(?:\s*\n)?(.+?)(?:\n|$)/)
+
+  if (nextLineMatch && nextLineMatch[1]) {
+    const nextLine = nextLineMatch[1]
+    const italicsMatch = nextLine.match(ITALICS_PATTERN)
+    if (italicsMatch && italicsMatch[1]) {
+      const instructions = italicsMatch[1].trim()
+      return {
+        title,
+        instructions,
+      }
+    }
+  }
+
+  return { title }
+}
+
+/**
+ * Register a file as a Magic Doc when it's read
+ * Only registers once per file path - the hook always reads latest content
+ */
+export function registerMagicDoc(filePath: string): void {
+  // Only register if not already tracked
+  if (!trackedMagicDocs.has(filePath)) {
+    trackedMagicDocs.set(filePath, {
+      path: filePath,
+    })
+  }
+}
+
+/**
+ * Create Magic Docs agent definition
+ */
+function getMagicDocsAgent(): BuiltInAgentDefinition {
+  return {
+    agentType: 'magic-docs',
+    whenToUse: 'Update Magic Docs',
+    tools: [FILE_EDIT_TOOL_NAME], // Only allow Edit
+    model: 'sonnet',
+    source: 'built-in',
+    baseDir: 'built-in',
+    getSystemPrompt: () => '', // Will use override systemPrompt
+  }
+}
+
+/**
+ * Update a single Magic Doc
+ */
+async function updateMagicDoc(
+  docInfo: MagicDocInfo,
+  context: REPLHookContext,
+): Promise<void> {
+  const { messages, systemPrompt, userContext, systemContext, toolUseContext } =
+    context
+
+  // Clone the FileStateCache to isolate Magic Docs operations. Delete this
+  // doc's entry so FileReadTool's dedup doesn't return a file_unchanged
+  // stub — we need the actual content to re-detect the header.
+  const clonedReadFileState = cloneFileStateCache(toolUseContext.readFileState)
+  clonedReadFileState.delete(docInfo.path)
+  const clonedToolUseContext: ToolUseContext = {
+    ...toolUseContext,
+    readFileState: clonedReadFileState,
+  }
+
+  // Read the document; if deleted or unreadable, remove from tracking
+  let currentDoc = ''
+  try {
+    const result = await FileReadTool.call(
+      { file_path: docInfo.path },
+      clonedToolUseContext,
+    )
+    const output = result.data as FileReadToolOutput
+    if (output.type === 'text') {
+      currentDoc = output.file.content
+    }
+  } catch (e: unknown) {
+    // FileReadTool wraps ENOENT in a plain Error("File does not exist...") with
+    // no .code, so check the message in addition to isFsInaccessible (EACCES/EPERM).
+    if (
+      isFsInaccessible(e) ||
+      (e instanceof Error && e.message.startsWith('File does not exist'))
+    ) {
+      trackedMagicDocs.delete(docInfo.path)
+      return
+    }
+    throw e
+  }
+
+  // Re-detect title and instructions from latest file content
+  const detected = detectMagicDocHeader(currentDoc)
+  if (!detected) {
+    // File no longer has magic doc header, remove from tracking
+    trackedMagicDocs.delete(docInfo.path)
+    return
+  }
+
+  // Build update prompt with latest title and instructions
+  const userPrompt = await buildMagicDocsUpdatePrompt(
+    currentDoc,
+    docInfo.path,
+    detected.title,
+    detected.instructions,
+  )
+
+  // Create a custom canUseTool that only allows Edit for magic doc files
+  const canUseTool = async (tool: Tool, input: unknown) => {
+    if (
+      tool.name === FILE_EDIT_TOOL_NAME &&
+      typeof input === 'object' &&
+      input !== null &&
+      'file_path' in input
+    ) {
+      const filePath = input.file_path
+      if (typeof filePath === 'string' && filePath === docInfo.path) {
+        return { behavior: 'allow' as const, updatedInput: input }
+      }
+    }
+    return {
+      behavior: 'deny' as const,
+      message: `only ${FILE_EDIT_TOOL_NAME} is allowed for ${docInfo.path}`,
+      decisionReason: {
+        type: 'other' as const,
+        reason: `only ${FILE_EDIT_TOOL_NAME} is allowed`,
+      },
+    }
+  }
+
+  // Run Magic Docs update using runAgent with forked context
+  for await (const _message of runAgent({
+    agentDefinition: getMagicDocsAgent(),
+    promptMessages: [createUserMessage({ content: userPrompt })],
+    toolUseContext: clonedToolUseContext,
+    canUseTool,
+    isAsync: true,
+    forkContextMessages: messages,
+    querySource: 'magic_docs',
+    override: {
+      systemPrompt,
+      userContext,
+      systemContext,
+    },
+    availableTools: clonedToolUseContext.options.tools,
+  })) {
+    // Just consume - let it run to completion
+  }
+}
+
+/**
+ * Magic Docs post-sampling hook that updates all tracked Magic Docs
+ */
+const updateMagicDocs = sequential(async function (
+  context: REPLHookContext,
+): Promise<void> {
+  const { messages, querySource } = context
+
+  if (querySource !== 'repl_main_thread') {
+    return
+  }
+
+  // Only update when conversation is idle (no tool calls in last turn)
+  const hasToolCalls = hasToolCallsInLastAssistantTurn(messages)
+  if (hasToolCalls) {
+    return
+  }
+
+  const docCount = trackedMagicDocs.size
+  if (docCount === 0) {
+    return
+  }
+
+  for (const docInfo of Array.from(trackedMagicDocs.values())) {
+    await updateMagicDoc(docInfo, context)
+  }
+})
+
+export async function initMagicDocs(): Promise<void> {
+  if (process.env.USER_TYPE === 'ant') {
+    // Register listener to detect magic docs when files are read
+    registerFileReadListener((filePath: string, content: string) => {
+      const result = detectMagicDocHeader(content)
+      if (result) {
+        registerMagicDoc(filePath)
+      }
+    })
+
+    registerPostSamplingHook(updateMagicDocs)
+  }
+}

package/services/MagicDocs/prompts.ts

@@ -0,0 +1,127 @@
+import { join } from 'path'
+import { getClaudeConfigHomeDir } from '../../utils/envUtils.js'
+import { getFsImplementation } from '../../utils/fsOperations.js'
+
+/**
+ * Get the Magic Docs update prompt template
+ */
+function getUpdatePromptTemplate(): string {
+  return `IMPORTANT: This message and these instructions are NOT part of the actual user conversation. Do NOT include any references to "documentation updates", "magic docs", or these update instructions in the document content.
+
+Based on the user conversation above (EXCLUDING this documentation update instruction message), update the Magic Doc file to incorporate any NEW learnings, insights, or information that would be valuable to preserve.
+
+The file {{docPath}} has already been read for you. Here are its current contents:
+<current_doc_content>
+{{docContents}}
+</current_doc_content>
+
+Document title: {{docTitle}}
+{{customInstructions}}
+
+Your ONLY task is to use the Edit tool to update the documentation file if there is substantial new information to add, then stop. You can make multiple edits (update multiple sections as needed) - make all Edit tool calls in parallel in a single message. If there's nothing substantial to add, simply respond with a brief explanation and do not call any tools.
+
+CRITICAL RULES FOR EDITING:
+- Preserve the Magic Doc header exactly as-is: # MAGIC DOC: {{docTitle}}
+- If there's an italicized line immediately after the header, preserve it exactly as-is
+- Keep the document CURRENT with the latest state of the codebase - this is NOT a changelog or history
+- Update information IN-PLACE to reflect the current state - do NOT append historical notes or track changes over time
+- Remove or replace outdated information rather than adding "Previously..." or "Updated to..." notes
+- Clean up or DELETE sections that are no longer relevant or don't align with the document's purpose
+- Fix obvious errors: typos, grammar mistakes, broken formatting, incorrect information, or confusing statements
+- Keep the document well organized: use clear headings, logical section order, consistent formatting, and proper nesting
+
+DOCUMENTATION PHILOSOPHY - READ CAREFULLY:
+- BE TERSE. High signal only. No filler words or unnecessary elaboration.
+- Documentation is for OVERVIEWS, ARCHITECTURE, and ENTRY POINTS - not detailed code walkthroughs
+- Do NOT duplicate information that's already obvious from reading the source code
+- Do NOT document every function, parameter, or line number reference
+- Focus on: WHY things exist, HOW components connect, WHERE to start reading, WHAT patterns are used
+- Skip: detailed implementation steps, exhaustive API docs, play-by-play narratives
+
+What TO document:
+- High-level architecture and system design
+- Non-obvious patterns, conventions, or gotchas
+- Key entry points and where to start reading code
+- Important design decisions and their rationale
+- Critical dependencies or integration points
+- References to related files, docs, or code (like a wiki) - help readers navigate to relevant context
+
+What NOT to document:
+- Anything obvious from reading the code itself
+- Exhaustive lists of files, functions, or parameters
+- Step-by-step implementation details
+- Low-level code mechanics
+- Information already in CLAUDE.md or other project docs
+
+Use the Edit tool with file_path: {{docPath}}
+
+REMEMBER: Only update if there is substantial new information. The Magic Doc header (# MAGIC DOC: {{docTitle}}) must remain unchanged.`
+}
+
+/**
+ * Load custom Magic Docs prompt from file if it exists
+ * Custom prompts can be placed at ~/.claude/magic-docs/prompt.md
+ * Use {{variableName}} syntax for variable substitution (e.g., {{docContents}}, {{docPath}}, {{docTitle}})
+ */
+async function loadMagicDocsPrompt(): Promise<string> {
+  const fs = getFsImplementation()
+  const promptPath = join(getClaudeConfigHomeDir(), 'magic-docs', 'prompt.md')
+
+  try {
+    return await fs.readFile(promptPath, { encoding: 'utf-8' })
+  } catch {
+    // Silently fall back to default if custom prompt doesn't exist or fails to load
+    return getUpdatePromptTemplate()
+  }
+}
+
+/**
+ * Substitute variables in the prompt template using {{variable}} syntax
+ */
+function substituteVariables(
+  template: string,
+  variables: Record<string, string>,
+): string {
+  // Single-pass replacement avoids two bugs: (1) $ backreference corruption
+  // (replacer fn treats $ literally), and (2) double-substitution when user
+  // content happens to contain {{varName}} matching a later variable.
+  return template.replace(/\{\{(\w+)\}\}/g, (match, key: string) =>
+    Object.prototype.hasOwnProperty.call(variables, key)
+      ? variables[key]!
+      : match,
+  )
+}
+
+/**
+ * Build the Magic Docs update prompt with variable substitution
+ */
+export async function buildMagicDocsUpdatePrompt(
+  docContents: string,
+  docPath: string,
+  docTitle: string,
+  instructions?: string,
+): Promise<string> {
+  const promptTemplate = await loadMagicDocsPrompt()
+
+  // Build custom instructions section if provided
+  const customInstructions = instructions
+    ? `
+
+DOCUMENT-SPECIFIC UPDATE INSTRUCTIONS:
+The document author has provided specific instructions for how this file should be updated. Pay extra attention to these instructions and follow them carefully:
+
+"${instructions}"
+
+These instructions take priority over the general rules below. Make sure your updates align with these specific guidelines.`
+    : ''
+
+  // Substitute variables in the prompt
+  const variables = {
+    docContents,
+    docPath,
+    docTitle,
+    customInstructions,
+  }
+
+  return substituteVariables(promptTemplate, variables)
+}