@zosmaai/pi-llm-wiki 0.2.0 → 0.2.2

package/.github/codeql/codeql-config.yml

@@ -0,0 +1,12 @@
+name: "CodeQL Config"
+
+queries:
+  - uses: security-and-quality
+
+# Suppress false positives for temporary file creation.
+# This is a single-user CLI tool — TOCTOU race conditions on temp directories
+# are not a valid threat model. The alerts only fire because tests pass
+# os.tmpdir() paths into production capture functions.
+query-filters:
+  - exclude:
+      id: js/insecure-temporary-file

package/.github/workflows/ci.yml

@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [20, 22, 23]
+        node-version: [20, 22, 23, 24, 25]
 
     steps:
       - uses: actions/checkout@v4

package/.github/workflows/codeql.yml

@@ -32,7 +32,7 @@ jobs:
         with:
           languages: ${{ matrix.language }}
           build-mode: ${{ matrix.build-mode }}
-          queries: security-and-quality
+          config-file: ./.github/codeql/codeql-config.yml
 
       - uses: github/codeql-action/analyze@v3
         with:

package/.github/workflows/release.yml

@@ -43,6 +43,14 @@ jobs:
           node -e "const p=require('./package.json'); p.version='${{ steps.version.outputs.VERSION }}'; require('fs').writeFileSync('./package.json', JSON.stringify(p, null, 2)+'\n')"
           npx biome check --fix package.json 2>&1
 
+      - name: Commit version bump back to main
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add package.json
+          git commit -m "chore(release): v${{ steps.version.outputs.VERSION }}"
+          git push origin HEAD:main
+
       - name: Generate Release Notes
         id: notes
         run: |

package/README.md

@@ -42,6 +42,14 @@ Drop sources into `raw/`, then:
 | `wiki_log_event`      | Record custom event                           |
 | `wiki_watch`          | Schedule auto-updates                         |
 
+## Features
+
+- **Configurable PDF extraction** — MarkItDown timeout adjustable via `WIKI_MARKITDOWN_TIMEOUT_MS` env var
+- **Smart content detection** — PDF bytes sniffed even from non-`.pdf` URLs, never written as markdown
+- **Original artifacts preserved** — URL captures save the fetched payload under `original/source.*`
+- **Clickable source links** — Captured URLs render as clickable Markdown links in source pages
+- **Reliable prompt forwarding** — Slash commands properly forward user arguments to the model
+
 ## Architecture
 
 Four layers with clear ownership:
@@ -67,6 +75,22 @@ Read [docs/architecture.md](docs/architecture.md) for details.
 
 See [CONTRIBUTING.md](CONTRIBUTING.md).
 
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=zosmaai/pi-llm-wiki&type=Date)](https://star-history.com/#zosmaai/pi-llm-wiki&Date)
+
+## Contributors
+
+<a href="https://github.com/zosmaai/pi-llm-wiki/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=zosmaai/pi-llm-wiki" alt="Contributors" />
+</a>
+
+---
+
+<div align="center">
+  <sub>Built with ❤️ by <a href="https://github.com/zosmaai">zosmaai</a></sub>
+</div>
+
 ## License
 
 MIT

package/docs/configuration.md

@@ -23,6 +23,12 @@ Wiki configuration lives in `.wiki/config.json`.
 | `auto_fix_lint`            | false   | Auto-fix lint issues               |
 | `batch_ingest_size`        | 3       | Sources processed per ingest batch |
 
+## Environment Variables
+
+| Variable                      | Default | Description                                     |
+| ----------------------------- | ------- | ----------------------------------------------- |
+| `WIKI_MARKITDOWN_TIMEOUT_MS` | 180000  | Timeout (ms) for MarkItDown PDF/text extraction |
+
 ## Page Frontmatter
 
 ```yaml

package/extensions/llm-wiki/lib/source-packet.ts

@@ -1,5 +1,5 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { extname, join } from "node:path";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { appendEvent } from "./metadata.js";
 import { type VaultPaths, exec, fmtDate, nextSourceId, readText, writeJson } from "./utils.js";
@@ -22,6 +22,69 @@ export interface CaptureResult {
   extracted: string;
 }
 
+const DEFAULT_MARKITDOWN_TIMEOUT_MS = 180_000;
+const DEFAULT_CURL_TIMEOUT_SECONDS = 30;
+
+function markitdownTimeoutMs(): number {
+  return positiveIntegerFromEnv("WIKI_MARKITDOWN_TIMEOUT_MS", DEFAULT_MARKITDOWN_TIMEOUT_MS);
+}
+
+function positiveIntegerFromEnv(name: string, fallback: number): number {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function isPdfUrl(url: string): boolean {
+  try {
+    return new URL(url).pathname.toLowerCase().endsWith(".pdf");
+  } catch {
+    return url.toLowerCase().split(/[?#]/, 1)[0].endsWith(".pdf");
+  }
+}
+
+function looksLikePdf(content: string): boolean {
+  return content.trimStart().startsWith("%PDF-");
+}
+
+function pdfExtractionFailureMessage(source: string): string {
+  return `_PDF content could not be converted to markdown from ${source}. Try increasing WIKI_MARKITDOWN_TIMEOUT_MS._\n`;
+}
+
+const URL_ORIGINAL_EXTENSIONS = new Set([".html", ".htm", ".md", ".pdf", ".txt", ".xml", ".json"]);
+
+function originalFileNameForUrl(url: string): string {
+  try {
+    const parsed = new URL(url);
+    const ext = extname(parsed.pathname).toLowerCase();
+    if (URL_ORIGINAL_EXTENSIONS.has(ext)) return `source${ext}`;
+  } catch {
+    const path = url.split(/[?#]/, 1)[0] ?? "";
+    const ext = extname(path).toLowerCase();
+    if (URL_ORIGINAL_EXTENSIONS.has(ext)) return `source${ext}`;
+  }
+
+  return "source.html";
+}
+
+async function preserveUrlOriginal(
+  pi: ExtensionAPI,
+  packetPath: string,
+  url: string,
+  signal?: AbortSignal,
+): Promise<void> {
+  const originalPath = join(packetPath, "original", originalFileNameForUrl(url));
+  try {
+    await exec(pi, "curl", ["-sL", "--max-time", "30", "-o", originalPath, url], {
+      signal,
+      timeout: 35_000,
+    });
+  } catch {
+    // Preserve best-effort extraction behavior even when the original artifact cannot be saved.
+  }
+}
+
 /** Capture a URL into a source packet. */
 export async function captureUrl(
   pi: ExtensionAPI,
@@ -35,11 +98,14 @@ export async function captureUrl(
   mkdirSync(join(packetPath, "original"), { recursive: true });
   mkdirSync(join(packetPath, "attachments"), { recursive: true });
 
+  await preserveUrlOriginal(pi, packetPath, url, signal);
+
   // Try to fetch and extract content
   let extracted = "";
   let title = url;
+  const isPdf = isPdfUrl(url);
 
-  // Try markitdown first
+  // Try MarkItDown first.
   const markitdown = await exec(
     pi,
     "sh",
@@ -53,7 +119,7 @@ export async function captureUrl(
         pi,
         "sh",
         ["-c", `uvx --from 'markitdown[pdf]' markitdown "${url}" 2>/dev/null || echo ""`],
-        { signal, timeout: 30_000 },
+        { signal, timeout: markitdownTimeoutMs() },
       );
       if (mdResult.stdout.trim()) {
         extracted = mdResult.stdout;
@@ -66,21 +132,35 @@ export async function captureUrl(
     }
   }
 
-  // Fallback: try fetch_content equivalent via curl
+  // Fallback: try fetch_content equivalent via curl for text/html sources.
+  // Do not write binary PDF bytes into extracted.md when PDF conversion fails.
   if (!extracted) {
-    try {
-      const curlResult = await exec(pi, "curl", ["-sL", "--max-time", "30", url], {
-        signal,
-        timeout: 35_000,
-      });
-      if (curlResult.stdout) {
-        extracted = curlResult.stdout;
-        // Try to extract title from HTML
-        const titleMatch = extracted.match(/<title>([^<]*)<\/title>/i);
-        if (titleMatch) title = titleMatch[1].trim();
+    if (isPdf) {
+      extracted = pdfExtractionFailureMessage(url);
+    } else {
+      try {
+        const curlResult = await exec(
+          pi,
+          "curl",
+          ["-sL", "--max-time", String(DEFAULT_CURL_TIMEOUT_SECONDS), url],
+          {
+            signal,
+            timeout: (DEFAULT_CURL_TIMEOUT_SECONDS + 5) * 1_000,
+          },
+        );
+        if (curlResult.stdout) {
+          if (looksLikePdf(curlResult.stdout)) {
+            extracted = pdfExtractionFailureMessage(url);
+          } else {
+            extracted = curlResult.stdout;
+            // Try to extract title from HTML
+            const titleMatch = extracted.match(/<title>([^<]*)<\/title>/i);
+            if (titleMatch) title = titleMatch[1].trim();
+          }
+        }
+      } catch {
+        // curl failed too
       }
-    } catch {
-      // curl failed too
     }
   }
 
@@ -126,12 +206,13 @@ export async function captureFile(
   mkdirSync(join(packetPath, "original"), { recursive: true });
   mkdirSync(join(packetPath, "attachments"), { recursive: true });
 
-  const content = readText(filePath);
+  const isPdf = filePath.toLowerCase().endsWith(".pdf");
+  const content = isPdf ? "" : readText(filePath);
   const fileName = filePath.split("/").pop() || "unknown";
 
-  // Try markitdown for PDFs
+  // Try MarkItDown for PDFs.
   let extracted = content;
-  if (filePath.toLowerCase().endsWith(".pdf")) {
+  if (isPdf) {
     const markitdown = await exec(
       pi,
       "sh",
@@ -145,13 +226,14 @@ export async function captureFile(
           pi,
           "sh",
           ["-c", `uvx --from 'markitdown[pdf]' markitdown "${filePath}" 2>/dev/null || echo ""`],
-          { signal, timeout: 30_000 },
+          { signal, timeout: markitdownTimeoutMs() },
         );
         if (mdResult.stdout.trim()) extracted = mdResult.stdout;
       } catch {
-        // fallback to original
+        extracted = pdfExtractionFailureMessage(filePath);
       }
     }
+    if (!extracted) extracted = pdfExtractionFailureMessage(filePath);
   }
 
   // Copy original to packet
@@ -227,7 +309,7 @@ export function captureText(paths: VaultPaths, text: string, title?: string): Ca
 function buildSourcePageSkeleton(manifest: Record<string, unknown>, extracted: string): string {
   const id = String(manifest.id);
   const title = String(manifest.title || id);
-  const url = manifest.url ? `\n> _Original: ${manifest.url}_` : "";
+  const url = manifest.url ? `\n> _Original: [${manifest.url}](${manifest.url})_` : "";
   const format = String(manifest.format || "unknown");
   const captured = String(manifest.captured || fmtDate());
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zosmaai/pi-llm-wiki",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "LLM Wiki for Pi — self-maintaining knowledge base following Karpathy's pattern. Obsidian-friendly, auto-updating, personal & company wiki.",
   "keywords": [
     "pi-package",

package/prompts/wiki-digest.md

@@ -1,6 +1,6 @@
 ---
 description: Generate a daily or weekly digest of wiki changes — new sources, pages, insights, and gaps.
-args: [--period daily|weekly]
+argument-hint: "[--period daily|weekly]"
 section: LLM Wiki
 topLevelCli: true
 ---
@@ -9,6 +9,10 @@ topLevelCli: true
 
 Generate a digest of recent wiki activity.
 
+## User Arguments
+
+$ARGUMENTS
+
 ## Steps
 
 1. Read `wiki/LOG.md` — filter entries since last digest

package/prompts/wiki-discover.md

@@ -1,6 +1,6 @@
 ---
 description: Auto-discover new sources from the web. Searches based on config topics and known knowledge gaps.
-args: [--topic <topic>]
+argument-hint: "[--topic <topic>]"
 section: LLM Wiki
 topLevelCli: true
 ---
@@ -9,6 +9,10 @@ topLevelCli: true
 
 Find new source material for the wiki by searching the web.
 
+## User Arguments
+
+$ARGUMENTS
+
 Read the LLM Wiki skill at `.pi/skills/llm-wiki/SKILL.md` first. Also read `config.yaml` for topics and feeds.
 
 ## Steps

package/prompts/wiki-ingest.md

@@ -1,6 +1,6 @@
 ---
 description: Process new source files in raw/ and update the wiki. Creates summaries, entities, concepts, and cross-references.
-args: [path]
+argument-hint: "[path]"
 section: LLM Wiki
 topLevelCli: true
 ---
@@ -9,6 +9,10 @@ topLevelCli: true
 
 Process new files in `raw/` and integrate them into the wiki.
 
+## User Arguments
+
+$ARGUMENTS
+
 Read the LLM Wiki skill at `.pi/skills/llm-wiki/SKILL.md` first to understand the full schema, page formats, and conventions.
 
 ## Steps

package/prompts/wiki-init.md

@@ -1,6 +1,6 @@
 ---
 description: Initialize a new LLM Wiki in the current directory. Creates the full directory structure, config, and template files.
-args: <topic> [--mode personal|company]
+argument-hint: "<topic> [--mode personal|company]"
 section: LLM Wiki
 topLevelCli: true
 ---
@@ -9,6 +9,10 @@ topLevelCli: true
 
 Initialize a new LLM Wiki in the current directory.
 
+## User Arguments
+
+$ARGUMENTS
+
 Read the LLM Wiki skill at `.pi/skills/llm-wiki/SKILL.md` (or wherever the skill is installed) first to understand the full schema and conventions.
 
 ## Steps

package/prompts/wiki-lint.md

@@ -1,6 +1,6 @@
 ---
 description: Health check the wiki. Detects contradictions, orphans, missing pages, stale claims, and knowledge gaps.
-args: [--fix]
+argument-hint: "[--fix]"
 section: LLM Wiki
 topLevelCli: true
 ---
@@ -9,6 +9,10 @@ topLevelCli: true
 
 Run a comprehensive health check on the wiki.
 
+## User Arguments
+
+$ARGUMENTS
+
 Read the LLM Wiki skill at `.pi/skills/llm-wiki/SKILL.md` first to understand the full schema and conventions.
 
 ## Steps

package/prompts/wiki-query.md

@@ -1,6 +1,6 @@
 ---
 description: Ask questions against the wiki. Synthesizes answers from wiki pages with cross-reference citations.
-args: <question>
+argument-hint: "<question>"
 section: LLM Wiki
 topLevelCli: true
 ---
@@ -9,6 +9,10 @@ topLevelCli: true
 
 Ask a question and get an answer synthesized from wiki content.
 
+## User Question
+
+$ARGUMENTS
+
 Read the LLM Wiki skill at `.pi/skills/llm-wiki/SKILL.md` first to understand the full schema and conventions.
 
 ## Steps

package/prompts/wiki-run.md

@@ -1,6 +1,6 @@
 ---
 description: Run the full wiki cycle: discover → ingest → lint. Optionally schedule for auto-updates.
-args: [--schedule daily|weekly]
+argument-hint: "[--schedule daily|weekly]"
 section: LLM Wiki
 topLevelCli: true
 ---
@@ -9,6 +9,10 @@ topLevelCli: true
 
 Run the complete wiki maintenance cycle: discover new sources, ingest them, and lint for health.
 
+## User Arguments
+
+$ARGUMENTS
+
 Read the LLM Wiki skill at `.pi/skills/llm-wiki/SKILL.md` first.
 
 ## Steps

package/prompts/wiki-status.md

@@ -1,6 +1,6 @@
 ---
 description: Show wiki health overview — source count, page stats, orphan count, last activity dates.
-args: []
+argument-hint: ""
 section: LLM Wiki
 topLevelCli: true
 ---

package/test/llm-wiki.test.ts

@@ -3,6 +3,8 @@ import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { captureFile, captureText, captureUrl } from "../extensions/llm-wiki/lib/source-packet.js";
+import { ensureVaultStructure, getVaultPaths } from "../extensions/llm-wiki/lib/utils.js";
 
 // ─── Helpers ────────────────────────────────────────────
 
@@ -111,11 +113,33 @@ describe("package structure", () => {
       expect(existsSync(path)).toBe(true);
       const content = readFile(path);
       expect(content).toContain("description:");
+      expect(content).toContain("argument-hint:");
       expect(content).toContain("section: LLM Wiki");
       expect(content).toContain("topLevelCli: true");
+      expect(content).not.toContain("\nargs:");
     }
   });
 
+  it("should include prompt arguments in templates that accept them", () => {
+    const promptsWithArgs = [
+      "wiki-init.md",
+      "wiki-ingest.md",
+      "wiki-query.md",
+      "wiki-lint.md",
+      "wiki-discover.md",
+      "wiki-run.md",
+      "wiki-digest.md",
+    ];
+    for (const prompt of promptsWithArgs) {
+      const content = readFile(join(rootDir, "prompts", prompt));
+      expect(content).toContain("$ARGUMENTS");
+    }
+
+    const query = readFile(join(rootDir, "prompts", "wiki-query.md"));
+    expect(query).toContain("## User Question");
+    expect(query).toContain("$ARGUMENTS");
+  });
+
   it("should have all wiki template files", () => {
     const t = join(rootDir, "skills", "llm-wiki", "templates");
     expect(existsSync(join(t, "INDEX.md"))).toBe(true);
@@ -157,6 +181,17 @@ describe("package structure", () => {
     }
   });
 
+  it("should keep MarkItDown timeout configurable and avoid PDF byte fallbacks", () => {
+    const sourcePacketPath = join(rootDir, "extensions", "llm-wiki", "lib", "source-packet.ts");
+    expect(existsSync(sourcePacketPath)).toBe(true);
+    const content = readFile(sourcePacketPath);
+    expect(content).toContain("WIKI_MARKITDOWN_TIMEOUT_MS");
+    expect(content).toContain("DEFAULT_MARKITDOWN_TIMEOUT_MS = 180_000");
+    expect(content).toContain("isPdfUrl(url)");
+    expect(content).toContain("looksLikePdf(curlResult.stdout)");
+    expect(content).toContain("pdfExtractionFailureMessage");
+  });
+
   it("should have a comprehensive README with install instructions", () => {
     const readme = readFile(join(rootDir, "README.md"));
     expect(readme).toContain("@zosmaai/pi-llm-wiki");
@@ -199,6 +234,162 @@ describe("skill frontmatter validation", () => {
 
 // ─── Wiki Directory Structure Tests ─────────────────────
 
+describe("source packet capture", () => {
+  const html = "<html><head><title>Example Page</title></head><body>Hello</body></html>";
+  const pdfBytes = "%PDF-1.7\n1 0 obj\n<</Type/Catalog>>\nendobj\n";
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `pi-llm-wiki-capture-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  /** Build a mock pi.exec that optionally handles curl -o file writes. */
+  function mockPi(stdout?: string, writeOriginal = true) {
+    return {
+      exec: async (command: string, args: string[]) => {
+        if (command === "sh") return { stdout: "no\n", stderr: "", code: 0 };
+        if (command === "curl" && args.includes("-o")) {
+          if (writeOriginal) {
+            const outputPath = args[args.indexOf("-o") + 1];
+            writeFileSync(outputPath, stdout ?? html, "utf-8");
+          }
+          return { stdout: "", stderr: "", code: 0 };
+        }
+        if (command === "curl") return { stdout: stdout ?? html, stderr: "", code: 0 };
+        throw new Error(`Unexpected command: ${command}`);
+      },
+    };
+  }
+
+  function makePaths() {
+    const p = getVaultPaths(join(tempDir, `wiki-${Math.random().toString(36).slice(2)}`));
+    ensureVaultStructure(p);
+    return p;
+  }
+
+  it("should preserve the original artifact for URL captures and render clickable links", async () => {
+    const paths = makePaths();
+    const pi = mockPi();
+
+    const url = "https://example.com/article";
+    const result = await captureUrl(pi as never, paths, url);
+
+    // Original artifact preserved
+    expect(existsSync(join(result.packetPath, "original", "source.html"))).toBe(true);
+    expect(readFile(join(result.packetPath, "original", "source.html"))).toBe(html);
+    expect(readFile(join(result.packetPath, "extracted.md"))).toBe(html);
+
+    // Clickable URL in source page
+    const sourcePage = readFile(result.sourcePagePath);
+    expect(sourcePage).toContain(`> _Original: [${url}](${url})_`);
+  });
+
+  it("should write PDF extraction failure message for .pdf URLs when MarkItDown is unavailable", async () => {
+    const paths = makePaths();
+    const pi = mockPi();
+
+    const url = "https://example.com/report.pdf";
+    const result = await captureUrl(pi as never, paths, url);
+
+    // Should NOT have written raw original for .pdf (no uvx)
+    expect(existsSync(join(result.packetPath, "original", "source.pdf"))).toBe(true);
+
+    // extracted.md should contain a failure message, not raw bytes
+    const extracted = readFile(join(result.packetPath, "extracted.md"));
+    expect(extracted).not.toContain("%PDF-");
+    expect(extracted).toContain("PDF content could not be converted");
+    expect(extracted).toContain(url);
+  });
+
+  it("should sniff %PDF- bytes from non-.pdf URLs and write a failure message instead", async () => {
+    const paths = makePaths();
+    // curl returns PDF bytes from a non-.pdf URL
+    const pi = mockPi(pdfBytes);
+
+    const url = "https://example.com/download?format=pdf";
+    const result = await captureUrl(pi as never, paths, url);
+
+    const extracted = readFile(join(result.packetPath, "extracted.md"));
+    expect(extracted).not.toContain("%PDF-");
+    expect(extracted).toContain("PDF content could not be converted");
+    expect(extracted).toContain(url);
+  });
+
+  it("should name original artifacts based on URL extension", async () => {
+    const cases: Array<{ url: string; expected: string }> = [
+      { url: "https://example.com/article.html", expected: "source.html" },
+      { url: "https://example.com/doc.pdf", expected: "source.pdf" },
+      { url: "https://example.com/notes.md", expected: "source.md" },
+      { url: "https://example.com/data.xml", expected: "source.xml" },
+      { url: "https://example.com/readme.txt", expected: "source.txt" },
+      { url: "https://example.com/page", expected: "source.html" },
+      { url: "https://example.com/page?format=pdf", expected: "source.html" },
+    ];
+
+    for (const { url, expected } of cases) {
+      const paths = makePaths();
+      const pi = mockPi();
+      const result = await captureUrl(pi as never, paths, url);
+      const originalFile = join(result.packetPath, "original", expected);
+      expect(existsSync(originalFile)).toBe(true);
+    }
+  });
+
+  it("should render source page without an Original: line for text captures", async () => {
+    const paths = makePaths();
+    const result = captureText(paths, "Some text content", "My Note");
+
+    const sourcePage = readFile(result.sourcePagePath);
+    expect(sourcePage).toContain("# My Note");
+    expect(sourcePage).not.toContain("Original:");
+    expect(sourcePage).toContain("_Auto-preview: Some text content_");
+  });
+
+  it("should truncate auto-preview to 500 characters", async () => {
+    const paths = makePaths();
+    const longText = "A".repeat(1000);
+    const result = captureText(paths, longText, "Long Note");
+
+    const sourcePage = readFile(result.sourcePagePath);
+    // Preview should be 500 chars + "..."
+    expect(sourcePage).toContain(`_Auto-preview: ${"A".repeat(500)}..._`);
+  });
+
+  it("should handle local PDF file capture failure message when MarkItDown is unavailable", async () => {
+    const paths = makePaths();
+    // Create a temporary PDF file
+    const pdfPath = join(tempDir, "test.pdf");
+    writeFileSync(pdfPath, pdfBytes, "utf-8");
+
+    const pi = mockPi();
+    const result = await captureFile(pi as never, paths, pdfPath);
+
+    const extracted = readFile(join(result.packetPath, "extracted.md"));
+    expect(extracted).not.toContain("%PDF-");
+    expect(extracted).toContain("PDF content could not be converted");
+  });
+
+  it("should copy local non-PDF file content to extracted.md", async () => {
+    const paths = makePaths();
+    const mdPath = join(tempDir, "notes.md");
+    writeFileSync(mdPath, "# My Notes\n\nHello world.", "utf-8");
+
+    const pi = mockPi();
+    const result = await captureFile(pi as never, paths, mdPath);
+
+    const extracted = readFile(join(result.packetPath, "extracted.md"));
+    expect(extracted).toContain("# My Notes");
+    expect(extracted).toContain("Hello world.");
+
+    // Original file should be preserved
+    expect(existsSync(join(result.packetPath, "original", "notes.md"))).toBe(true);
+  });
+});
+
 describe("wiki directory structure", () => {
   let wikiDir: string;