@connormartin/seed-network-agent 0.1.0

package/README.md

@@ -0,0 +1,109 @@
+# seed-network-agent
+
+Seed Network Agent is a thin Seed Network wrapper around upstream Pi.
+
+We do not fork Pi core here.
+
+## Boundary
+
+Seed-owned behavior:
+- `prompts/*`
+- `src/extension/*` — Pi extension entrypoint and shared extension types
+- `src/features/*` — feature modules registered by the extension
+- `src/wizard.ts`
+- `src/store.ts`
+
+Pi boundary:
+- `src/pi.ts`
+
+Only `src/pi.ts` should import or execute Pi directly. Feature modules are normal upstream Pi extension code registered through `src/extension/index.ts`.
+
+## Feature layout
+
+Features should be easy to find and remove. Add new Seed Agent behavior under `src/features/<feature-name>/`, then register it from `src/extension/index.ts`.
+
+Current features:
+- `features/branding` — Seed header/title customization.
+- `features/onboarding` — `/onboarding` command and onboarding questionnaire.
+- `features/agent-auth` — `/seed` Agent Auth management commands.
+- `features/submit-deal-pdf` — `/submit-deal` PDF intake, local extraction, model interpretation, upload, and capability execution.
+
+Pi supports this directory-extension shape directly: a multi-file extension is an `index.ts` entrypoint plus helper modules.
+
+## What we changed
+
+1. Start Pi with Seed Network Agent resources loaded.
+2. Register Seed feature modules from `src/extension/index.ts`.
+3. Add a deterministic onboarding wizard.
+4. Load versioned feature questionnaires from each feature directory.
+5. Save onboarding answers locally through `src/store.ts`.
+6. Add `/submit-deal` for local PDF deal intake.
+
+## What we do not change
+
+- Pi model/provider logic
+- Pi auth behavior
+- Pi session engine
+- Pi tool execution internals
+- Pi TUI internals
+- Pi package manager
+
+## Install
+
+Install the published CLI globally:
+
+```bash
+npm install -g @connormartin/seed-network-agent
+seed
+```
+
+Or run the latest version without a global install:
+
+```bash
+npx @connormartin/seed-network-agent@latest
+```
+
+The CLI checks npm for updates at startup at most once per day and prints the exact update command when a newer version is available. Disable this with `SEED_NETWORK_AGENT_NO_UPDATE_CHECK=1`.
+
+## Run locally
+
+From the repository root:
+
+```bash
+pnpm agent
+```
+
+Build the publishable CLI from `apps/agent`:
+
+```bash
+pnpm --filter @connormartin/seed-network-agent build
+pnpm --filter @connormartin/seed-network-agent start
+```
+
+Run `/onboarding` inside the agent to start the onboarding wizard.
+
+Run `/submit-deal` inside the agent to create a Seed Network deal from a local pitch deck PDF and the first intake questions.
+
+If you need the previous startup behavior, set `SEED_NETWORK_AGENT_AUTOSTART_ONBOARDING=true` before launching the agent.
+
+You can forward normal Pi flags through the wrapper:
+
+```bash
+pnpm agent -- --model anthropic/claude-sonnet-4-5
+```
+
+Local onboarding progress is written under `~/.seed-network-agent/onboarding/`.
+
+## Seed Agent Auth
+
+The wrapper can connect to the Seed Network web app as an Agent Auth client:
+
+```bash
+/seed connect [provider-url]
+/seed status
+/seed sync-onboarding
+/seed disconnect
+```
+
+By default the provider URL is `SEED_NETWORK_AGENT_AUTH_PROVIDER` or `http://localhost:3000`.
+Agent Auth identity and grants are stored locally under `~/.seed-network-agent/auth/`.

package/dist/agent-auth-storage.js

@@ -0,0 +1,111 @@
+import { chmod, mkdir, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+export class SeedAgentAuthStorage {
+    root;
+    agentsDir;
+    providersDir;
+    constructor(baseDir = path.join(os.homedir(), ".seed-network-agent", "auth")) {
+        this.root = baseDir;
+        this.agentsDir = path.join(this.root, "agents");
+        this.providersDir = path.join(this.root, "providers");
+    }
+    async getHostIdentity() {
+        await ensurePrivateDir(this.root);
+        return readJson(path.join(this.root, "host.json"));
+    }
+    async setHostIdentity(host) {
+        await ensurePrivateDir(this.root);
+        await writeJsonAtomic(path.join(this.root, "host.json"), host);
+    }
+    async deleteHostIdentity() {
+        await rm(path.join(this.root, "host.json"), { force: true });
+    }
+    async getAgentConnection(agentId) {
+        await ensurePrivateDir(this.root);
+        await ensurePrivateDir(this.agentsDir);
+        return readJson(this.agentPath(agentId));
+    }
+    async setAgentConnection(agentId, conn) {
+        await ensurePrivateDir(this.root);
+        await ensurePrivateDir(this.agentsDir);
+        await writeJsonAtomic(this.agentPath(agentId), conn);
+    }
+    async deleteAgentConnection(agentId) {
+        await rm(this.agentPath(agentId), { force: true });
+    }
+    async listAgentConnections() {
+        await ensurePrivateDir(this.root);
+        await ensurePrivateDir(this.agentsDir);
+        return readJsonDir(this.agentsDir);
+    }
+    async getProviderConfig(issuer) {
+        await ensurePrivateDir(this.root);
+        await ensurePrivateDir(this.providersDir);
+        return readJson(this.providerPath(issuer));
+    }
+    async setProviderConfig(issuer, config) {
+        await ensurePrivateDir(this.root);
+        await ensurePrivateDir(this.providersDir);
+        await writeJsonAtomic(this.providerPath(issuer), config);
+    }
+    async listProviderConfigs() {
+        await ensurePrivateDir(this.root);
+        await ensurePrivateDir(this.providersDir);
+        return readJsonDir(this.providersDir);
+    }
+    agentPath(agentId) {
+        return path.join(this.agentsDir, `${safeFileName(agentId)}.json`);
+    }
+    providerPath(issuer) {
+        return path.join(this.providersDir, `${safeFileName(issuer)}.json`);
+    }
+}
+async function readJson(filePath) {
+    try {
+        const raw = await readFile(filePath, "utf8");
+        await chmod(filePath, 0o600);
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+async function readJsonDir(dirPath) {
+    try {
+        const entries = await readdir(dirPath, { withFileTypes: true });
+        const values = [];
+        for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.endsWith(".json"))
+                continue;
+            const value = await readJson(path.join(dirPath, entry.name));
+            if (value !== null)
+                values.push(value);
+        }
+        return values;
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+async function writeJsonAtomic(filePath, value) {
+    await ensurePrivateDir(path.dirname(filePath));
+    const tmpPath = `${filePath}.${process.pid}.tmp`;
+    await writeFile(tmpPath, `${JSON.stringify(value, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    await chmod(tmpPath, 0o600);
+    await rename(tmpPath, filePath);
+}
+async function ensurePrivateDir(dirPath) {
+    await mkdir(dirPath, { recursive: true, mode: 0o700 });
+    await chmod(dirPath, 0o700);
+}
+function safeFileName(value) {
+    return Buffer.from(value).toString("base64url");
+}
+function isNodeError(error) {
+    return typeof error === "object" && error !== null && "code" in error;
+}

package/dist/cli.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { runPi } from "./pi.js";
+await runPi(process.argv.slice(2));

package/dist/extension/index.js

@@ -0,0 +1,10 @@
+import { registerAgentAuthCommands } from "../features/agent-auth/register.js";
+import { registerBranding } from "../features/branding/register.js";
+import { registerOnboarding } from "../features/onboarding/register.js";
+import { registerSubmitDealPdf } from "../features/submit-deal-pdf/register.js";
+export default function seedNetworkExtension(pi) {
+    registerBranding(pi);
+    registerOnboarding(pi);
+    registerSubmitDealPdf(pi);
+    registerAgentAuthCommands(pi);
+}

package/dist/extension/pi-types.js

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

package/dist/features/agent-auth/register.js

@@ -0,0 +1,69 @@
+import { connectSeedAgent, DEFAULT_PROVIDER_URL, disconnectSeedAgents, listSeedAgentConnections, syncOnboardingSubmission, } from "../../seed-agent-auth.js";
+import { OnboardingStore } from "../../store.js";
+export function registerAgentAuthCommands(pi) {
+    pi.registerCommand("seed", {
+        description: "Manage Seed Network Agent Auth: connect, status, sync-onboarding, disconnect",
+        getArgumentCompletions: completeSeedCommand,
+        handler: async (args, ctx) => {
+            if (ctx.hasUI === false) {
+                throw new Error("/seed requires interactive Pi UI.");
+            }
+            await handleSeedCommand(args, ctx);
+        },
+    });
+}
+function completeSeedCommand(prefix) {
+    const commands = [
+        { value: "connect", label: "connect", description: "Connect this local agent to Seed Network" },
+        { value: "status", label: "status", description: "Show saved Agent Auth connections and grants" },
+        { value: "sync-onboarding", label: "sync-onboarding", description: "Upload the latest local onboarding submission" },
+        { value: "disconnect", label: "disconnect", description: "Revoke and remove local Agent Auth connections" },
+    ];
+    const firstToken = prefix.trimStart().split(/\s+/, 1)[0] ?? "";
+    const filtered = commands.filter((command) => command.value.startsWith(firstToken));
+    return filtered.length > 0 ? filtered : null;
+}
+async function handleSeedCommand(args, ctx) {
+    const [subcommand = "status", ...rest] = args.trim().split(/\s+/).filter(Boolean);
+    switch (subcommand) {
+        case "connect": {
+            const providerUrl = rest[0] ?? DEFAULT_PROVIDER_URL;
+            ctx.ui.notify(`Connecting Seed Network Agent to ${providerUrl}…`, "info");
+            const result = await connectSeedAgent(providerUrl, ctx.ui);
+            ctx.ui.notify(`Seed Network Agent connected: ${result.agentId} (${result.status}).`, "info");
+            return;
+        }
+        case "status": {
+            const connections = await listSeedAgentConnections();
+            if (connections.length === 0) {
+                ctx.ui.notify(`No Seed Network Agent Auth connection. Run /seed connect ${DEFAULT_PROVIDER_URL}`, "warning");
+                return;
+            }
+            const lines = connections.map((connection) => {
+                const grants = connection.capabilityGrants
+                    .map((grant) => `${grant.capability}:${grant.status}`)
+                    .join(", ");
+                return `${connection.providerName} ${connection.agentId} (${connection.mode}) — ${grants || "no grants"}`;
+            });
+            ctx.ui.notify(lines.join("\n"), "info");
+            return;
+        }
+        case "sync-onboarding": {
+            const submission = await new OnboardingStore().loadLatestSubmission();
+            if (!submission) {
+                ctx.ui.notify("No completed onboarding submission found. Run /onboarding first.", "warning");
+                return;
+            }
+            const result = await syncOnboardingSubmission(submission, ctx.ui);
+            ctx.ui.notify(`Seed Network onboarding synced: ${JSON.stringify(result.data ?? result)}`, "info");
+            return;
+        }
+        case "disconnect": {
+            const count = await disconnectSeedAgents(ctx.ui);
+            ctx.ui.notify(`Disconnected ${count} Seed Network Agent connection${count === 1 ? "" : "s"}.`, "info");
+            return;
+        }
+        default:
+            ctx.ui.notify("Unknown /seed command. Use: /seed connect [provider-url], /seed status, /seed sync-onboarding, /seed disconnect", "warning");
+    }
+}

package/dist/features/branding/register.js

@@ -0,0 +1,25 @@
+export function registerBranding(pi) {
+    pi.on("session_start", (_event, ctx) => {
+        installSeedBranding(ctx);
+    });
+}
+function installSeedBranding(ctx) {
+    ctx.ui.setTitle?.("The Seed Network");
+    ctx.ui.setHeader?.((_tui, theme) => ({
+        render(width) {
+            const rule = "─".repeat(Math.max(0, Math.min(width, 72)));
+            const accent = (value) => theme.fg("accent", value);
+            const muted = (value) => theme.fg("muted", value);
+            const dim = (value) => theme.fg("dim", value);
+            return [
+                "",
+                accent(rule),
+                `${accent("🌱 ")}${theme.bold("Seed Network Agent")}`,
+                dim("Run /onboarding to start onboarding, or /submit-deal to submit a company."),
+                accent(rule),
+                "",
+            ];
+        },
+        invalidate() { },
+    }));
+}

package/dist/features/onboarding/questionnaire.v1.json

@@ -0,0 +1,89 @@
+{
+  "version": "onboarding.v1",
+  "title": "Seed Network onboarding",
+  "description": "A short local-only onboarding flow for Seed Network Agent.",
+  "questions": [
+    {
+      "id": "name",
+      "label": "Name",
+      "type": "text",
+      "required": true,
+      "prompt": "What should Seed Network Agent call you?",
+      "placeholder": "Your name"
+    },
+    {
+      "id": "role",
+      "label": "Role",
+      "type": "single_select",
+      "required": true,
+      "prompt": "Which role best describes you right now?",
+      "options": [
+        {
+          "value": "founder",
+          "label": "Founder"
+        },
+        {
+          "value": "investor",
+          "label": "Investor"
+        },
+        {
+          "value": "operator",
+          "label": "Operator"
+        },
+        {
+          "value": "builder",
+          "label": "Builder"
+        },
+        {
+          "value": "other",
+          "label": "Other"
+        }
+      ]
+    },
+    {
+      "id": "primary_goal",
+      "label": "Goal",
+      "type": "text",
+      "required": true,
+      "prompt": "What is the main outcome you want from Seed Network Agent?",
+      "placeholder": "e.g. track deal flow, manage investor follow-ups, prepare intro requests"
+    },
+    {
+      "id": "workflow_focus",
+      "label": "Focus",
+      "type": "single_select",
+      "required": true,
+      "prompt": "Which workflow should we optimize around first?",
+      "options": [
+        {
+          "value": "telegram_triage",
+          "label": "Telegram triage"
+        },
+        {
+          "value": "intro_requests",
+          "label": "Intro requests"
+        },
+        {
+          "value": "deal_intake",
+          "label": "Deal intake"
+        },
+        {
+          "value": "meeting_followups",
+          "label": "Meeting follow-ups"
+        },
+        {
+          "value": "other",
+          "label": "Something else"
+        }
+      ]
+    },
+    {
+      "id": "notes",
+      "label": "Notes",
+      "type": "text",
+      "required": false,
+      "prompt": "Anything else we should know for this local onboarding pass?",
+      "placeholder": "Optional"
+    }
+  ]
+}

package/dist/features/onboarding/register.js

@@ -0,0 +1,78 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { getPreferredConnection, syncOnboardingSubmission } from "../../seed-agent-auth.js";
+import { OnboardingStore } from "../../store.js";
+import { runOnboardingWizard } from "../../wizard.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const onboardingQuestionsPath = path.join(__dirname, "questionnaire.v1.json");
+let autoStarted = false;
+export function registerOnboarding(pi) {
+    pi.on("session_start", async (event, ctx) => {
+        if (event.reason !== "startup")
+            return;
+        if (process.env.SEED_NETWORK_AGENT_AUTOSTART_ONBOARDING !== "true")
+            return;
+        if (ctx.hasUI === false)
+            return;
+        if (autoStarted)
+            return;
+        autoStarted = true;
+        await startOnboarding(ctx, "auto");
+    });
+    pi.registerCommand("onboarding", {
+        description: "Start the Seed Network deterministic local onboarding wizard",
+        handler: async (_args, ctx) => {
+            if (ctx.hasUI === false) {
+                throw new Error("/onboarding requires interactive Pi UI.");
+            }
+            await startOnboarding(ctx, "manual");
+        },
+    });
+}
+async function startOnboarding(ctx, source) {
+    const questionnaire = await loadQuestionnaire();
+    const store = new OnboardingStore();
+    const progress = await store.loadProgress();
+    let initialAnswers;
+    if (progress?.questionnaireVersion === questionnaire.version) {
+        const answerCount = Object.keys(progress.answers).length;
+        const resume = await ctx.ui.confirm("Resume onboarding?", `Found ${answerCount} saved answer${answerCount === 1 ? "" : "s"} from ${progress.updatedAt}.\n\nResume from local progress?`);
+        if (resume)
+            initialAnswers = progress.answers;
+    }
+    const result = await runOnboardingWizard(ctx.ui, questionnaire, {
+        initialAnswers,
+        onAnswer: (question, answer) => store.recordAnswer(questionnaire.version, question, answer),
+    });
+    if (result.cancelled || !result.submission) {
+        const prefix = source === "auto" ? "Startup onboarding" : "Seed Network onboarding";
+        ctx.ui.notify(`${prefix} cancelled. Progress is saved locally.`, "warning");
+        return;
+    }
+    const submissionPath = await store.saveSubmission(result.submission);
+    ctx.ui.notify(`Seed Network onboarding saved locally: ${submissionPath}`, "info");
+    const connection = await getPreferredConnection();
+    if (!connection) {
+        ctx.ui.notify("Run /seed connect to sync this onboarding to Seed Network when ready.", "info");
+        return;
+    }
+    const shouldSync = await ctx.ui.confirm("Sync onboarding?", "Seed Network Agent is connected. Upload this local onboarding submission to your Seed Network account now?");
+    if (!shouldSync)
+        return;
+    try {
+        await syncOnboardingSubmission(result.submission, ctx.ui);
+        ctx.ui.notify("Seed Network onboarding synced.", "info");
+    }
+    catch (error) {
+        ctx.ui.notify(`Seed Network onboarding sync failed: ${errorMessage(error)}`, "error");
+    }
+}
+async function loadQuestionnaire(filePath = onboardingQuestionsPath) {
+    const raw = await readFile(filePath, "utf8");
+    return JSON.parse(raw);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/features/submit-deal-pdf/interpretation.js

@@ -0,0 +1,88 @@
+import { MIN_EXTRACTED_TEXT_CHARS } from "./types.js";
+export async function interpretDealText(text, interpreter) {
+    const trimmed = truncate(text.trim(), 24_000);
+    const warnings = [];
+    if (trimmed.length < MIN_EXTRACTED_TEXT_CHARS) {
+        return {
+            confidence: "low",
+            warnings: ["Skipped interpretation because extracted PDF text was insufficient."],
+        };
+    }
+    if (interpreter) {
+        try {
+            return sanitizeInterpretation(await interpreter(trimmed));
+        }
+        catch (error) {
+            warnings.push(`Pi model interpretation failed: ${errorMessage(error)}`);
+        }
+    }
+    else {
+        warnings.push("Pi model interpretation skipped: no active Pi model was available to the command.");
+    }
+    return sanitizeInterpretation({
+        ...heuristicInterpretation(trimmed),
+        confidence: "low",
+        warnings,
+    });
+}
+function heuristicInterpretation(text) {
+    const email = text.match(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/i)?.[0];
+    const links = Array.from(new Set(text.match(/https?:\/\/[^\s)\]}>\"]+/gi) ?? []));
+    const website = links.find((link) => !/(twitter|x\.com|linkedin|crunchbase|instagram|facebook)\./i.test(link));
+    const socialLinks = links
+        .filter((link) => /(twitter|x\.com|linkedin|crunchbase|instagram|facebook)\./i.test(link))
+        .slice(0, 8)
+        .join("\n");
+    return {
+        ...(website ? { website } : {}),
+        ...(email ? { email } : {}),
+        ...(socialLinks ? { socialLinks } : {}),
+    };
+}
+function sanitizeInterpretation(value) {
+    const warnings = [];
+    if (!isRecord(value))
+        return { confidence: "low", warnings: ["Interpretation did not return an object."] };
+    const confidence = parseConfidence(value.confidence);
+    const interpretedWarnings = Array.isArray(value.warnings)
+        ? value.warnings.filter((item) => typeof item === "string" && item.trim().length > 0)
+        : [];
+    return {
+        ...optionalString(value, "companyName", 160),
+        ...optionalString(value, "summary", 1000),
+        ...optionalString(value, "founderNames", 500),
+        ...optionalString(value, "website", 500),
+        ...optionalString(value, "email", 320),
+        ...optionalString(value, "socialLinks", 2000),
+        ...optionalNumber(value, "valuationUsd"),
+        ...optionalNumber(value, "totalAllocationUsd"),
+        ...optionalString(value, "terms", 2000),
+        confidence,
+        warnings: [...interpretedWarnings, ...warnings],
+    };
+}
+function optionalString(record, field, maxLength) {
+    const value = record[field];
+    if (typeof value !== "string")
+        return {};
+    const trimmed = truncate(value.trim(), maxLength);
+    return trimmed ? { [field]: trimmed } : {};
+}
+function optionalNumber(record, field) {
+    const value = record[field];
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+        return {};
+    return { [field]: Math.round(value * 100) / 100 };
+}
+function parseConfidence(value) {
+    return value === "high" || value === "medium" || value === "low" ? value : "low";
+}
+function truncate(value, maxLength) {
+    return value.length <= maxLength ? value : value.slice(0, maxLength);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/features/submit-deal-pdf/local-pdf.js

@@ -0,0 +1,91 @@
+import { createHash } from "node:crypto";
+import { readFile, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { PDFParse } from "pdf-parse";
+import { MAX_DEAL_DECK_BYTES, MIN_EXTRACTED_TEXT_CHARS, } from "./types.js";
+export async function validateLocalPdf(inputPath) {
+    const resolvedPath = resolveLocalPath(inputPath);
+    const fileName = path.basename(resolvedPath);
+    const warnings = [];
+    if (!fileName.toLowerCase().endsWith(".pdf")) {
+        warnings.push("File extension is not .pdf, but magic bytes will be checked.");
+    }
+    let fileStat;
+    try {
+        fileStat = await stat(resolvedPath);
+    }
+    catch (error) {
+        throw new Error(`PDF file does not exist or is not readable: ${resolvedPath}`, { cause: error });
+    }
+    if (!fileStat.isFile())
+        throw new Error(`PDF path is not a regular file: ${resolvedPath}`);
+    if (fileStat.size <= 0)
+        throw new Error("PDF file is empty.");
+    if (fileStat.size > MAX_DEAL_DECK_BYTES)
+        throw new Error("PDF file exceeds 25MB.");
+    const buffer = await readFile(resolvedPath);
+    if (buffer.subarray(0, 5).toString("utf8") !== "%PDF-") {
+        throw new Error("File is not a PDF: missing %PDF- magic bytes.");
+    }
+    return {
+        path: resolvedPath,
+        fileName,
+        size: fileStat.size,
+        sha256: createHash("sha256").update(buffer).digest("hex"),
+        buffer,
+        warnings,
+    };
+}
+export async function extractPdfText(buffer) {
+    const warnings = [];
+    const extractedAt = new Date().toISOString();
+    try {
+        const parser = new PDFParse({ data: buffer });
+        try {
+            const result = await parser.getText();
+            const text = normalizeExtractedText(result.text ?? "");
+            const pageCount = typeof result.total === "number" ? result.total : undefined;
+            if (text.length < MIN_EXTRACTED_TEXT_CHARS) {
+                warnings.push("PDF text extraction returned very little text; the deck may be scanned/image-only.");
+            }
+            return {
+                parserVersion: "pdf-parse@2",
+                extractedAt,
+                text,
+                ...(pageCount ? { pageCount } : {}),
+                warnings,
+            };
+        }
+        finally {
+            await parser.destroy();
+        }
+    }
+    catch (error) {
+        warnings.push(`PDF text extraction failed: ${errorMessage(error)}`);
+        return {
+            parserVersion: "pdf-parse@2",
+            extractedAt,
+            text: "",
+            warnings,
+        };
+    }
+}
+function normalizeExtractedText(text) {
+    return text
+        .replace(/\u0000/g, "")
+        .replace(/[ \t]+\n/g, "\n")
+        .replace(/\n{4,}/g, "\n\n\n")
+        .trim();
+}
+function resolveLocalPath(inputPath) {
+    const stripped = inputPath.trim().replace(/^@/, "").replace(/^["']|["']$/g, "");
+    const unescaped = stripped.replace(/\\([ \\()&'\"\[\]{}!$`*?;<>|#~])/g, "$1");
+    const expanded = unescaped === "~" || unescaped.startsWith(`~${path.sep}`)
+        ? path.join(os.homedir(), unescaped.slice(2))
+        : unescaped;
+    return path.resolve(expanded);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}