pi-voice-input 0.2.12 → 0.2.14

package/README.md

@@ -1,193 +1,158 @@
 # pi Voice Input
 
-A publishable, pure TypeScript [pi](https://pi.dev/) extension for Linux and macOS voice dictation into pi's editor.
+Voice dictation for [pi](https://pi.dev/). Press one shortcut, speak naturally, and insert the transcript into the editor without sending the prompt automatically.
 
-- Press `Ctrl+Shift+R` once to start recording.
-- Press `Ctrl+Shift+R` again to stop.
-- The extension sends the audio to VolcEngine WebSocket ASR.
-- The recognized text is inserted into pi's editor without submitting.
+## Why use it?
 
-Current scope:
+Typing long prompts can slow you down. `pi-voice-input` lets you:
 
-- Linux uses `pw-record` from PipeWire tools or `arecord` from alsa-utils.
-- macOS uses `afrecord` when present, otherwise `ffmpeg` with AVFoundation.
-- A VolcEngine Speech API key is required.
-- This is not a local/offline ASR engine.
+- capture ideas quickly while you are thinking out loud
+- dictate long instructions, notes, bug reports, or code review comments
+- speak naturally in Chinese, English, or a mix of both
+- keep your hands on the keyboard with a simple toggle shortcut
+- review or edit the inserted text before you submit it
+- optionally polish dictated text with one of your configured pi models
 
-The provider layer is intended to be extensible. **Current version supports only VolcEngine WebSocket ASR.**
+## Features
 
-No Python, `uv`, or upload service is required for normal shortcut usage. On macOS systems without `afrecord`, install `ffmpeg` for recording.
+- **One-key dictation**: `Ctrl+Shift+R` starts recording; press it again to stop and insert text.
+- **Editor-safe workflow**: transcription is pasted into the current editor only. It does not auto-submit.
+- **Chinese/English mixed input**: handles prompts that switch between Chinese, English, product names, and technical terms.
+- **Works on Linux and macOS**: uses common system recording tools.
+- **Lowers sound while you speak**: automatically turns down system audio during recording, then restores it afterwards.
+- **Optional transcript polish**: use a pi model to clean up punctuation and wording before insertion.
+- **Simple setup commands**: configure from inside pi with `/voice init` and `/voice key`.
 
-## Architecture
+Current speech provider: **VolcEngine Speech ASR**. A VolcEngine Speech API key is required.
 
-```text
-pi extension: extensions/index.ts → extensions/voice-input.ts
-  ├─ registers Ctrl+Shift+R and /voice commands
-  ├─ starts/stops a local recorder process
-  │    ├─ Linux preferred: pw-record
-  │    ├─ Linux fallback: arecord
-  │    └─ macOS: afrecord, or ffmpeg/AVFoundation fallback
-  ├─ ducks system output volume while the microphone is listening
-  ├─ records a temporary 16 kHz mono 16-bit WAV
-  ├─ parses the WAV container in TypeScript and extracts raw PCM
-  ├─ sends PCM frames to the configured ASR provider via ws
-  │    └─ current provider: VolcEngine /api/v3/sauc/bigmodel_nostream
-  ├─ optionally post-processes raw ASR text with a configured pi model
-  │    └─ default: disabled; set polishModel to enable it
-  └─ pastes the final transcript into pi's editor
-```
-
-Runtime package dependency:
-
-- `ws`
-
-System dependency, one of:
-
-- Linux: `pw-record` from PipeWire tools, preferred
-- Linux: `arecord` from alsa-utils, fallback
-- macOS: `afrecord` when present, or `ffmpeg` from Homebrew (`brew install ffmpeg`) as the AVFoundation fallback
-
-On macOS, grant Terminal, ffmpeg, or your pi host app microphone permission when prompted. If macOS has previously denied microphone access, enable it in System Settings → Privacy & Security → Microphone.
-
-## Install / Update
-
-Install the published package with pi:
+## Install
 
 ```bash
 pi install npm:pi-voice-input
 ```
 
-Update to the latest published version:
+Update later with:
 
 ```bash
 pi update npm:pi-voice-input
 ```
 
-If pi is already running, restart pi after installing or updating. `/reload` may not replace code that was already loaded by the current pi process.
+Restart pi after installing or updating.
 
-## Providers
+## First-time setup
 
-The extension is structured around a provider boundary: recording, editor insertion, and command handling are generic; ASR transport/protocol logic is provider-specific.
+1. Install the extension:
 
-Currently implemented provider:
+   ```bash
+   pi install npm:pi-voice-input
+   ```
 
-- VolcEngine WebSocket ASR (`bigmodel_nostream`)
+2. Restart pi.
 
-Planned provider direction:
+3. Create the local config:
 
-- add more ASR providers without changing the shortcut/user workflow
-- keep provider credentials and options isolated in config
+   ```text
+   /voice init
+   ```
 
-## Configure
+4. Add your VolcEngine Speech API key:
 
-All plugin settings live in one JSON file:
+   ```text
+   /voice key
+   ```
 
-```text
-~/.pi/agent/voice-input.config.json
-```
+   Get your key here:
 
-Package-local and project-local env files are not read.
+   https://console.volcengine.com/speech/new/setting/apikeys?projectName=default
 
-Create or normalize the file from inside pi:
+5. Check that pi sees your setup:
 
-```text
-/voice init
-```
+   ```text
+   /voice config
+   ```
 
-Then set the VolcEngine Speech API key:
+6. Press `Ctrl+Shift+R`, speak, then press `Ctrl+Shift+R` again to insert the transcript.
+
+## Use
+
+Press:
 
 ```text
-/voice key
+Ctrl+Shift+R
 ```
 
-The key URL is also shown inside pi when the key is missing, when you run `/voice key`, and in `/voice help`:
+Then speak naturally in Chinese, English, or both. Press `Ctrl+Shift+R` again to stop recording. The recognized text appears in the editor at your cursor.
 
-https://console.volcengine.com/speech/new/setting/apikeys?projectName=default
+Useful commands:
 
-The config file is plain JSON and can be edited directly:
-
-```json
-{
-  "volcApiKey": "",
-  "polishModel": "",
-  "duckSystemVolume": true,
-  "duckSystemVolumeFactor": 0.5,
-  "duckSystemVolumeFadeMs": 300
-}
+```text
+/voice start    start recording
+/voice stop     stop, transcribe, and insert text
+/voice toggle   start or stop recording
+/voice cancel   stop and discard the recording
+/voice status   show current recorder state
+/voice config   show non-secret configuration
+/voice key      set or replace the API key
+/voice help     show setup help
 ```
 
-`polishModel` is disabled by default. Set it to any model shown by `pi --list-models` to enable transcript polish. If polishing fails, the raw ASR transcript is inserted instead.
-
-`duckSystemVolume` is enabled by default. While recording, the extension lowers system output volume to `duckSystemVolumeFactor` of the original volume using a short ease-in/ease-out fade (`duckSystemVolumeFadeMs`), then restores the saved volume when recording stops or is cancelled. Linux uses `wpctl` or `pactl`; macOS uses `osascript`.
+## Optional: polish dictated text
 
-Verify the effective non-secret config:
+By default, pi inserts the raw transcript. To let a pi model clean up punctuation and wording, set `polishModel` in:
 
 ```text
-/voice config
+~/.pi/agent/voice-input.config.json
 ```
 
-## Usage
+Use any model name shown by:
 
-Shortcut:
-
-```text
-Ctrl+Shift+R
+```bash
+pi --list-models
 ```
 
-Slash commands:
+Example:
 
-```text
-/voice start    # start recording
-/voice stop     # stop, transcribe, insert text
-/voice toggle   # start if idle, stop if recording
-/voice cancel   # stop recording and discard local audio without transcribing
-/voice status   # show recorder state
-/voice config   # show effective non-secret config and whether API key is detected
-/voice init     # create or normalize ~/.pi/agent/voice-input.config.json
-/voice key      # prompt for and save the current provider API key
-/voice help     # show setup help, including the explicit VolcEngine API key URL
+```json
+{
+  "volcApiKey": "",
+  "polishModel": "your-model-name"
+}
 ```
 
-## Notes
+If polishing fails, the raw transcript is inserted instead.
 
-- The extension uses post-recording WebSocket ASR: it records locally to a per-run temporary WAV, sends the stopped recording in chunks, then deletes the temporary audio. It is optimized for fast voice input, not live subtitles.
-- The default ASR segment size is intentionally larger than realtime packet sizes because this workflow sends already-recorded audio.
-- The transcript is inserted into the editor only; it is not submitted automatically.
-- Recorder stdout/stderr is not logged to disk, to avoid retaining potentially sensitive runtime data.
-- On startup, legacy `~/.pi/agent/voice-input/recordings` and `~/.pi/agent/voice-input/logs` artifacts are cleaned up when they are not part of an active recording.
-- When `polishModel` is set, polishing uses the unsent editor draft and recent session messages as context, but outputs only the refined voice text to insert at the current cursor. It must not reconstruct the full draft; the final text is pasted without replacing existing editor content.
-- While recording, the status line shows `● Mic on: [device name] — press Ctrl+Shift+R again to stop/transcribe` in the current theme accent color; no separate popup is shown when recording starts.
-- By default, system output volume is ducked to 50% of its previous level with a 300 ms ease-in/ease-out fade while the microphone is listening, then restored after recording stops.
+## System requirements
 
-## Development
+Linux needs one recording tool:
 
-See [CONTRIBUTING.md](CONTRIBUTING.md) for contribution guidelines, validation commands, and pull request expectations.
+- `pw-record` from PipeWire tools, recommended
+- or `arecord` from alsa-utils
 
-Clone the repo and install dependencies:
+macOS uses the built-in recorder when available. If recording does not work, install ffmpeg:
 
 ```bash
-git clone git@github.com:tr-nc/pi-voice-input.git
-cd pi-voice-input
-npm install
+brew install ffmpeg
 ```
 
-Run directly from the package checkout:
+On macOS, allow microphone access for your terminal or pi host app when prompted. You can also check System Settings → Privacy & Security → Microphone.
 
-```bash
-pi -e .
-```
+## Privacy notes
 
-Or install the local checkout while developing:
+- Your API key is stored locally in `~/.pi/agent/voice-input.config.json`.
+- Recordings are temporary and are removed after use.
+- Transcribed text is inserted into the editor so you can review it before submitting.
 
-```bash
-pi install .
-```
+## Troubleshooting
 
-After changing the extension while pi is open, run:
+- Run `/voice status` to see whether recording is active.
+- Run `/voice config` to confirm the API key is detected.
+- Run `/voice key` again if the key was changed or expired.
+- On macOS, check microphone permission if recording immediately fails.
+- On Linux, make sure `pw-record` or `arecord` is installed and your microphone works in other apps.
 
-```text
-/reload
-```
+## Development
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for contribution guidelines.
 
 ## Roadmap
 
@@ -196,5 +161,4 @@ See [ROADMAP.md](ROADMAP.md) for planned user-visible work.
 ## Links
 
 - API key settings: https://console.volcengine.com/speech/new/setting/apikeys?projectName=default
-- ASR product page: https://www.volcengine.com/product/asr
-- WebSocket ASR docs: https://www.volcengine.com/docs/6561/1354869?lang=zh
+- VolcEngine ASR: https://www.volcengine.com/product/asr

package/extensions/voice-input.ts

@@ -6,6 +6,7 @@ import { randomUUID } from "node:crypto";
 import {
   chmodSync,
   existsSync,
+  lstatSync,
   mkdirSync,
   mkdtempSync,
   readFileSync,
@@ -24,6 +25,25 @@ const CONFIG_PATH = path.join(homedir(), ".pi", "agent", "voice-input.config.jso
 const VOLC_API_KEY_URL = "https://console.volcengine.com/speech/new/setting/apikeys?projectName=default";
 const DEFAULT_SHORTCUT = Key.ctrlShift("r");
 const DEFAULT_POSTPROCESS_MODEL = "";
+const DEFAULT_POSTPROCESS_CONTEXT_TOKENS = 20000;
+const POSTPROCESS_GIT_LOG_LIMIT = 10;
+const POSTPROCESS_DIRECTORY_DEPTH = 2;
+const POSTPROCESS_DIRECTORY_TOKENS = 20000;
+const SKIPPED_DIRECTORY_ENTRIES = new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  ".next",
+  ".nuxt",
+  ".turbo",
+  ".cache",
+  "logs",
+  "recordings",
+]);
 const POSTPROCESS_SYSTEM_PROMPT = `You are the speech-recognition postprocessor for the pi voice input extension. Your only job is to polish the raw ASR text into text that the plugin can paste verbatim at the current cursor position in the pi editor.
 
 Interaction contract:
@@ -88,7 +108,7 @@ type VoiceConfig = {
   postprocessModel: string;
   postprocessTimeoutMs: number;
   postprocessMaxTokens: number;
-  postprocessContextChars: number;
+  postprocessContextTokens: number;
   duckSystemVolume: boolean;
   duckSystemVolumeFactor: number;
   duckSystemVolumeFadeMs: number;
@@ -222,7 +242,7 @@ function getConfig(): VoiceConfig {
     postprocessModel: polishModel,
     postprocessTimeoutMs: 30000,
     postprocessMaxTokens: 2048,
-    postprocessContextChars: 6000,
+    postprocessContextTokens: DEFAULT_POSTPROCESS_CONTEXT_TOKENS,
     duckSystemVolume: fileConfig.duckSystemVolume,
     duckSystemVolumeFactor: fileConfig.duckSystemVolumeFactor,
     duckSystemVolumeFadeMs: fileConfig.duckSystemVolumeFadeMs,
@@ -956,16 +976,77 @@ async function transcribePcm(pcm: Buffer, durationMs: number, config: VoiceConfi
   };
 }
 
-function tailText(text: string, maxChars: number): string {
-  if (maxChars <= 0) return "";
-  if (text.length <= maxChars) return text;
-  return `…${text.slice(-maxChars)}`;
+function estimateTokens(text: string): number {
+  let tokens = 0;
+  let asciiRun = 0;
+  const flushAscii = () => {
+    if (asciiRun > 0) {
+      tokens += Math.ceil(asciiRun / 4);
+      asciiRun = 0;
+    }
+  };
+
+  for (const char of text) {
+    if (/\s/u.test(char)) {
+      flushAscii();
+    } else if (/[^\x00-\x7F]/u.test(char)) {
+      flushAscii();
+      tokens += 1;
+    } else {
+      asciiRun += 1;
+    }
+  }
+  flushAscii();
+  return tokens;
+}
+
+function takeTokensFromStart(text: string, maxTokens: number): string {
+  if (maxTokens <= 0 || !text) return "";
+  if (estimateTokens(text) <= maxTokens) return text;
+
+  let low = 0;
+  let high = text.length;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (estimateTokens(text.slice(0, mid)) <= maxTokens) low = mid;
+    else high = mid - 1;
+  }
+  return text.slice(0, low);
+}
+
+function takeTokensFromEnd(text: string, maxTokens: number): string {
+  if (maxTokens <= 0 || !text) return "";
+  if (estimateTokens(text) <= maxTokens) return text;
+
+  let low = 0;
+  let high = text.length;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (estimateTokens(text.slice(text.length - mid)) <= maxTokens) low = mid;
+    else high = mid - 1;
+  }
+  return text.slice(text.length - low);
+}
+
+function limitTokensFromStart(text: string, maxTokens: number, marker = "\n…(truncated to fit token budget)"): string {
+  if (maxTokens <= 0) return "";
+  if (estimateTokens(text) <= maxTokens) return text;
+  const markerTokens = estimateTokens(marker);
+  return `${takeTokensFromStart(text, Math.max(0, maxTokens - markerTokens)).trimEnd()}${marker}`;
+}
+
+function limitTokensFromEnd(text: string, maxTokens: number, marker = "…(older context omitted to fit token budget)\n"): string {
+  if (maxTokens <= 0) return "";
+  if (estimateTokens(text) <= maxTokens) return text;
+  const markerTokens = estimateTokens(marker);
+  return `${marker}${takeTokensFromEnd(text, Math.max(0, maxTokens - markerTokens)).trimStart()}`;
 }
 
-function truncateText(text: string, maxChars: number): string {
-  if (maxChars <= 0) return "";
-  if (text.length <= maxChars) return text;
-  return `${text.slice(0, maxChars)}…`;
+function redactSensitiveText(text: string): string {
+  return text
+    .replace(/(\bVOLC_API_KEY\s*=\s*)[^\s"']+/giu, "$1[redacted]")
+    .replace(/((?:\b|["'])(?:volcApiKey|api[_-]?key|apikey|access[_-]?token|secret|password)(?:\b|["'])\s*[:=]\s*["']?)[^"'\s,}]+/giu, "$1[redacted]")
+    .replace(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/giu, "[redacted-uuid]");
 }
 
 function textFromContent(content: unknown): string {
@@ -982,27 +1063,163 @@ function textFromContent(content: unknown): string {
     .join("\n");
 }
 
-function getEditorContext(ctx: ExtensionContext, maxChars: number): string {
-  if (maxChars <= 0) return "";
+function getEditorContext(ctx: ExtensionContext): string {
   try {
-    return tailText(ctx.ui.getEditorText(), maxChars);
+    return redactSensitiveText(ctx.ui.getEditorText()).trim();
   } catch {
     return "";
   }
 }
 
-function getRecentSessionContext(ctx: ExtensionContext, maxChars: number): string {
-  if (maxChars <= 0) return "";
+function getRecentSessionContext(ctx: ExtensionContext): string {
   const lines: string[] = [];
   for (const entry of ctx.sessionManager.getBranch()) {
     if (entry.type !== "message") continue;
     const message = entry.message as { role?: unknown; content?: unknown };
     if (message.role !== "user" && message.role !== "assistant") continue;
-    const text = textFromContent(message.content).replace(/\s+/g, " ").trim();
+    const text = redactSensitiveText(textFromContent(message.content)).trim();
     if (!text) continue;
-    lines.push(`${message.role}: ${truncateText(text, 1200)}`);
+    lines.push(`${message.role}: ${text}`);
   }
-  return tailText(lines.slice(-8).join("\n"), maxChars);
+  return lines.join("\n\n");
+}
+
+function buildConversationContext(ctx: ExtensionContext, maxTokens: number): { editorContext: string; sessionContext: string } {
+  if (maxTokens <= 0) return { editorContext: "", sessionContext: "" };
+
+  const editorContext = getEditorContext(ctx);
+  const sessionContext = getRecentSessionContext(ctx);
+  const editorSection = [
+    "--- Context: current unsent editor draft (context only; do not output wholesale) ---",
+    editorContext || "(empty)",
+  ].join("\n");
+  const sessionHeader = "--- Context: recent conversation ---\n";
+  const totalTokens = estimateTokens([editorSection, sessionHeader, sessionContext || "(empty)"].join("\n\n"));
+  if (totalTokens <= maxTokens) return { editorContext, sessionContext };
+
+  const editorTokenBudget = Math.min(5000, Math.floor(maxTokens / 4));
+  const limitedEditor = editorContext ? limitTokensFromEnd(editorContext, editorTokenBudget) : "";
+  const fixedTokens = estimateTokens(
+    [
+      "--- Context: current unsent editor draft (context only; do not output wholesale) ---",
+      limitedEditor || "(empty)",
+      sessionHeader,
+    ].join("\n\n"),
+  );
+  const sessionBudget = Math.max(0, maxTokens - fixedTokens);
+  return {
+    editorContext: limitedEditor,
+    sessionContext: sessionContext ? limitTokensFromEnd(sessionContext, sessionBudget) : "",
+  };
+}
+
+function commandOutputInDir(cwd: string, command: string, args: string[], timeoutMs = 2500): string {
+  const result = spawnSync(command, args, { cwd, encoding: "utf8", timeout: timeoutMs, maxBuffer: 1024 * 1024 * 8 });
+  if (result.status !== 0) return "";
+  return (result.stdout || "").trim();
+}
+
+function findGitRoot(startDir: string): string | null {
+  const root = commandOutputInDir(startDir, "git", ["rev-parse", "--show-toplevel"], 1500);
+  return root || null;
+}
+
+function buildGitContext(cwd: string): string {
+  const gitRoot = findGitRoot(cwd);
+  if (!gitRoot) return "(not a git repository)";
+
+  const recentLog = commandOutputInDir(
+    gitRoot,
+    "git",
+    ["log", `-${POSTPROCESS_GIT_LOG_LIMIT}`, "--date=short", "--pretty=format:%h %ad %an %s"],
+    2500,
+  );
+
+  return [
+    `Repository root: ${gitRoot}`,
+    `Recent commits (up to ${POSTPROCESS_GIT_LOG_LIMIT}):`,
+    recentLog ? redactSensitiveText(recentLog) : "(no commits yet)",
+  ].join("\n");
+}
+
+function shouldSkipDirectoryEntry(name: string): boolean {
+  return SKIPPED_DIRECTORY_ENTRIES.has(name);
+}
+
+function safeReadDir(dir: string): string[] {
+  try {
+    return readdirSync(dir).sort((a, b) => a.localeCompare(b));
+  } catch {
+    return [];
+  }
+}
+
+function formatDirectoryEntry(fullPath: string, name: string, isCwd = false): string {
+  try {
+    const stat = lstatSync(fullPath);
+    const suffix = stat.isDirectory() ? "/" : stat.isSymbolicLink() ? "@" : "";
+    return `${name}${suffix}${isCwd ? "  <-- current" : ""}`;
+  } catch {
+    return `${name}${isCwd ? "  <-- current" : ""}`;
+  }
+}
+
+function buildTreeLines(dir: string, depth: number, prefix = "", state = { entries: 0, omitted: 0 }): string[] {
+  if (depth < 0) return [];
+  const names = safeReadDir(dir).filter((name) => !shouldSkipDirectoryEntry(name));
+  const visibleNames = names.slice(0, 120);
+  state.omitted += Math.max(0, names.length - visibleNames.length);
+  const lines: string[] = [];
+
+  visibleNames.forEach((name, index) => {
+    const fullPath = path.join(dir, name);
+    const isLast = index === visibleNames.length - 1;
+    const connector = isLast ? "└── " : "├── ";
+    const childPrefix = `${prefix}${isLast ? "    " : "│   "}`;
+    const label = formatDirectoryEntry(fullPath, name);
+    lines.push(`${prefix}${connector}${label}`);
+    state.entries += 1;
+
+    try {
+      const stat = lstatSync(fullPath);
+      if (stat.isDirectory() && !stat.isSymbolicLink() && depth > 0) {
+        lines.push(...buildTreeLines(fullPath, depth - 1, childPrefix, state));
+      }
+    } catch {
+      // ignore unreadable entries
+    }
+  });
+
+  return lines;
+}
+
+function buildDirectoryContext(cwd: string, maxTokens: number): string {
+  if (maxTokens <= 0) return "";
+  const parent = path.dirname(cwd);
+  const isRootDirectory = path.resolve(parent) === path.resolve(cwd);
+  const cwdName = path.basename(cwd) || cwd;
+  const parentEntries = isRootDirectory
+    ? []
+    : safeReadDir(parent)
+        .filter((name) => !shouldSkipDirectoryEntry(name))
+        .slice(0, 160)
+        .map((name) => formatDirectoryEntry(path.join(parent, name), name, path.resolve(parent, name) === path.resolve(cwd)));
+  const state = { entries: 0, omitted: 0 };
+  const cwdTree = buildTreeLines(cwd, POSTPROCESS_DIRECTORY_DEPTH - 1, "", state);
+  const text = [
+    `Current directory: ${cwd}`,
+    isRootDirectory ? "Parent directory: (current directory is filesystem root; no parent directory)" : `Parent directory: ${parent}`,
+    "Parent entries (one level up):",
+    isRootDirectory ? "- (none; current directory is filesystem root)" : parentEntries.length ? parentEntries.map((entry) => `- ${entry}`).join("\n") : "- (empty or unreadable)",
+    "",
+    `Current directory tree (${cwdName}/, ${POSTPROCESS_DIRECTORY_DEPTH} levels deep):`,
+    `${cwdName}/`,
+    cwdTree.length ? cwdTree.join("\n") : "└── (empty or no readable child entries)",
+    state.omitted > 0 ? `…(${state.omitted} entries omitted)` : "",
+  ]
+    .filter(Boolean)
+    .join("\n");
+  return limitTokensFromStart(text, maxTokens);
 }
 
 function simplifyModelReference(value: string): string {
@@ -1145,9 +1362,10 @@ function getFullEditorText(ctx: ExtensionContext): string {
 }
 
 function buildPostprocessPrompt(ctx: ExtensionContext, rawText: string, config: VoiceConfig): string {
-  const contextBudget = config.postprocessContextChars;
-  const editorContext = getEditorContext(ctx, Math.floor(contextBudget / 2));
-  const sessionContext = getRecentSessionContext(ctx, Math.ceil(contextBudget / 2));
+  const { editorContext, sessionContext } = buildConversationContext(ctx, config.postprocessContextTokens);
+  const cwd = process.cwd();
+  const gitContext = buildGitContext(cwd);
+  const directoryContext = buildDirectoryContext(cwd, POSTPROCESS_DIRECTORY_TOKENS);
 
   return [
     "Polish only the raw ASR text below, using context only when it helps disambiguate the user's intent.",
@@ -1160,15 +1378,22 @@ function buildPostprocessPrompt(ctx: ExtensionContext, rawText: string, config:
     "The true cursor position is not marked in the draft shown here; the pi editor owns the actual insertion point. Do not guess the cursor and synthesize a full surrounding sentence.",
     "Preserve layout: if the raw ASR text is one line, output one line unless the user explicitly dictated line breaks or another multiline layout.",
     "If the raw speech is an inline insertion, continuation, a few words, or a phrase, output only the newly spoken words or phrase.",
+    "Use the git history and directory structure only as reference context for project names, files, APIs, and intent; never summarize them in the output.",
     "Example: draft is `Please make this function async and [cursor].`, raw speech is `add error handling`, correct output is `add error handling`, not `Please make this function async and add error handling.`.",
     "Example: draft is `This variable name is [cursor]unclear`, raw speech is `still`, correct output is `still`, not `This variable name is still unclear`.",
     "",
     "--- Context: current unsent editor draft (context only; do not output wholesale) ---",
-    editorContext.trim() || "(empty)",
+    editorContext || "(empty)",
     "",
-    "--- Context: recent conversation ---",
+    "--- Context: recent conversation (recent tail, capped at 20k estimated tokens with the editor draft) ---",
     sessionContext || "(empty)",
     "",
+    "--- Context: git history (latest commit summaries only) ---",
+    gitContext || "(empty)",
+    "",
+    "--- Context: directory structure (parent one level; current directory two levels deep) ---",
+    directoryContext || "(empty)",
+    "",
     "--- Raw ASR text ---",
     rawText.trim(),
   ].join("\n");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-voice-input",
-  "version": "0.2.12",
+  "version": "0.2.14",
   "description": "Press Ctrl+Shift+R to dictate prompts into Pi using VolcEngine ASR",
   "type": "module",
   "keywords": [