@connormartin/seed-network-agent 0.1.0

package/dist/update-check.js

@@ -0,0 +1,131 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+const DEFAULT_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const REGISTRY_TIMEOUT_MS = 1500;
+const UPDATE_CACHE_PATH = path.join(os.homedir(), ".seed-network-agent", "update-check.json");
+export async function maybeNotifyUpdate(packageRoot) {
+    if (isUpdateCheckDisabled())
+        return;
+    try {
+        const packageInfo = await readPackageInfo(packageRoot);
+        if (!packageInfo.name || !packageInfo.version)
+            return;
+        const cached = await readCache();
+        const latestVersion = shouldUseCache(cached, packageInfo.name)
+            ? cached.latestVersion
+            : await fetchAndCacheLatestVersion(packageInfo.name);
+        if (!latestVersion || !isNewerVersion(latestVersion, packageInfo.version))
+            return;
+        notifyUpdate({
+            packageName: packageInfo.name,
+            currentVersion: packageInfo.version,
+            latestVersion,
+        });
+    }
+    catch {
+        // Update checks should never prevent the local agent from starting.
+    }
+}
+async function readPackageInfo(packageRoot) {
+    const raw = await readFile(path.join(packageRoot, "package.json"), "utf8");
+    return JSON.parse(raw);
+}
+function isUpdateCheckDisabled() {
+    return isTruthy(process.env.SEED_NETWORK_AGENT_NO_UPDATE_CHECK)
+        || isTruthy(process.env.SEED_AGENT_NO_UPDATE_CHECK)
+        || isTruthy(process.env.PI_OFFLINE)
+        || process.env.NO_UPDATE_NOTIFIER === "1";
+}
+function isTruthy(value) {
+    return value === "1" || value === "true" || value === "yes";
+}
+function shouldUseCache(cache, packageName) {
+    if (!cache?.checkedAt || cache.packageName !== packageName)
+        return false;
+    const checkedAt = Date.parse(cache.checkedAt);
+    return Number.isFinite(checkedAt) && Date.now() - checkedAt < DEFAULT_CHECK_INTERVAL_MS;
+}
+async function fetchAndCacheLatestVersion(packageName) {
+    let latestVersion;
+    try {
+        const registryPackageName = packageName.startsWith("@")
+            ? packageName.replace("/", "%2F")
+            : encodeURIComponent(packageName);
+        const response = await fetch(`https://registry.npmjs.org/${registryPackageName}/latest`, {
+            signal: AbortSignal.timeout(REGISTRY_TIMEOUT_MS),
+            headers: { accept: "application/json" },
+        });
+        if (response.ok) {
+            const body = await response.json();
+            latestVersion = typeof body.version === "string" ? body.version : undefined;
+        }
+    }
+    finally {
+        await writeCache({
+            checkedAt: new Date().toISOString(),
+            packageName,
+            latestVersion,
+        }).catch(() => undefined);
+    }
+    return latestVersion;
+}
+async function readCache() {
+    try {
+        const raw = await readFile(UPDATE_CACHE_PATH, "utf8");
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+async function writeCache(cache) {
+    await mkdir(path.dirname(UPDATE_CACHE_PATH), { recursive: true });
+    const tmpPath = `${UPDATE_CACHE_PATH}.${process.pid}.tmp`;
+    await writeFile(tmpPath, `${JSON.stringify(cache, null, 2)}\n`, "utf8");
+    await rename(tmpPath, UPDATE_CACHE_PATH);
+}
+function notifyUpdate(input) {
+    const updateCommand = `npm install -g ${input.packageName}@latest`;
+    process.stderr.write([
+        "",
+        `Seed Network Agent update available: ${input.currentVersion} → ${input.latestVersion}`,
+        `Update with: ${updateCommand}`,
+        `Or run once with: npx ${input.packageName}@latest`,
+        "Set SEED_NETWORK_AGENT_NO_UPDATE_CHECK=1 to disable this check.",
+        "",
+    ].join("\n"));
+}
+function isNewerVersion(candidate, current) {
+    const candidateVersion = parseSemver(candidate);
+    const currentVersion = parseSemver(current);
+    if (!candidateVersion || !currentVersion)
+        return candidate !== current;
+    for (const key of ["major", "minor", "patch"]) {
+        if (candidateVersion[key] > currentVersion[key])
+            return true;
+        if (candidateVersion[key] < currentVersion[key])
+            return false;
+    }
+    if (!candidateVersion.prerelease && currentVersion.prerelease)
+        return true;
+    if (candidateVersion.prerelease && !currentVersion.prerelease)
+        return false;
+    return false;
+}
+function parseSemver(value) {
+    const match = value.trim().match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/);
+    if (!match)
+        return undefined;
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3]),
+        prerelease: match[4],
+    };
+}
+function isNodeError(error) {
+    return typeof error === "object" && error !== null && "code" in error;
+}

package/dist/wizard.js

@@ -0,0 +1,116 @@
+export async function runOnboardingWizard(ui, questionnaire, options = {}) {
+    validateQuestionnaire(questionnaire);
+    const answers = { ...(options.initialAnswers ?? {}) };
+    ui.notify?.(options.startMessage ?? `${questionnaire.title}: starting local onboarding.`, "info");
+    for (const question of questionnaire.questions) {
+        const answer = await askQuestion(ui, question, answers[question.id]);
+        if (!answer) {
+            return { cancelled: true, answers };
+        }
+        answers[question.id] = answer;
+        await options.onAnswer?.(question, answer);
+    }
+    const confirmed = await ui.confirm(options.reviewTitle ?? "Review onboarding answers", formatReview(questionnaire, answers, options));
+    if (!confirmed) {
+        if (!options.suppressReviewCancelledMessage) {
+            ui.notify?.(options.reviewCancelledMessage ?? "Onboarding review cancelled. Progress remains saved locally.", "warning");
+        }
+        return { cancelled: true, answers };
+    }
+    return {
+        cancelled: false,
+        answers,
+        submission: {
+            questionnaireVersion: questionnaire.version,
+            title: questionnaire.title,
+            submittedAt: new Date().toISOString(),
+            answers,
+        },
+    };
+}
+async function askQuestion(ui, question, existing) {
+    const label = question.label ?? question.id;
+    const title = existing
+        ? `${label}: ${question.prompt}\nCurrent answer: ${displayAnswer(existing)}`
+        : `${label}: ${question.prompt}`;
+    if (question.type === "text") {
+        return askTextQuestion(ui, question, title);
+    }
+    return askSingleSelectQuestion(ui, question, title);
+}
+async function askTextQuestion(ui, question, title) {
+    while (true) {
+        const value = await ui.input(title, question.placeholder);
+        if (value === undefined)
+            return undefined;
+        const trimmed = value.trim();
+        if (question.required && trimmed.length === 0) {
+            ui.notify?.("This question is required.", "warning");
+            continue;
+        }
+        return buildAnswer(question, trimmed);
+    }
+}
+async function askSingleSelectQuestion(ui, question, title) {
+    const choices = question.options ?? [];
+    const labels = choices.map((option) => option.label);
+    while (true) {
+        const selected = await ui.select(title, labels);
+        if (selected === undefined)
+            return undefined;
+        const option = choices.find((candidate) => candidate.label === selected);
+        if (!option) {
+            ui.notify?.("Please choose one of the listed options.", "warning");
+            continue;
+        }
+        return buildAnswer(question, option.value, option.label);
+    }
+}
+function buildAnswer(question, value, label) {
+    return {
+        questionId: question.id,
+        questionLabel: question.label ?? question.id,
+        questionPrompt: question.prompt,
+        type: question.type,
+        value,
+        label,
+        answeredAt: new Date().toISOString(),
+    };
+}
+function displayAnswer(answer) {
+    return (answer.label ?? answer.value) || "(blank)";
+}
+function formatReview(questionnaire, answers, options = {}) {
+    const lines = [
+        options.reviewDescription
+            ?? questionnaire.description
+            ?? "Review your answers before saving the final local submission.",
+        "",
+    ];
+    for (const question of questionnaire.questions) {
+        const answer = answers[question.id];
+        lines.push(`${question.label ?? question.id}: ${answer ? displayAnswer(answer) : "(unanswered)"}`);
+    }
+    lines.push("", options.reviewConfirmPrompt ?? "Save this final submission locally?");
+    return lines.join("\n");
+}
+function validateQuestionnaire(questionnaire) {
+    if (!questionnaire.version)
+        throw new Error("Questionnaire is missing version.");
+    if (!Array.isArray(questionnaire.questions))
+        throw new Error("Questionnaire questions must be an array.");
+    const ids = new Set();
+    for (const question of questionnaire.questions) {
+        if (!question.id)
+            throw new Error("Question is missing id.");
+        if (ids.has(question.id))
+            throw new Error(`Duplicate question id: ${question.id}`);
+        ids.add(question.id);
+        if (question.type !== "text" && question.type !== "single_select") {
+            throw new Error(`Unsupported question type for ${question.id}: ${String(question.type)}`);
+        }
+        if (question.type === "single_select" && (!question.options || question.options.length === 0)) {
+            throw new Error(`single_select question ${question.id} must include options.`);
+        }
+    }
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@connormartin/seed-network-agent",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "bin": {
+    "seed": "./dist/cli.js",
+    "seed-agent": "./dist/cli.js",
+    "seed-network-agent": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "prompts",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json && mkdir -p dist/features/onboarding dist/features/submit-deal-pdf && cp src/features/onboarding/questionnaire.v1.json dist/features/onboarding/questionnaire.v1.json && cp src/features/submit-deal-pdf/questionnaire.v1.json dist/features/submit-deal-pdf/questionnaire.v1.json && chmod +x dist/cli.js",
+    "dev": "tsx src/cli.ts",
+    "start": "node dist/cli.js",
+    "prepack": "npm run build"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@auth/agent": "0.4.6",
+    "@earendil-works/pi-ai": "^0.74.0",
+    "@earendil-works/pi-coding-agent": "^0.74.0",
+    "pdf-parse": "^2.4.5"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.3"
+  }
+}

package/prompts/SYSTEM.md

@@ -0,0 +1,12 @@
+You are Seed Network Agent, a thin wrapper around upstream Pi.
+
+The seed network is a private network of angel investors that collectively identify, diligence, and invest in early stage startups.
+
+Keep the Seed-specific layer obvious:
+- Use clear, direct language.
+- Be explicit when a behavior is part of the Seed onboarding wrapper.
+- Be explicit that onboarding answers stay local unless the user connects Agent Auth and approves syncing.
+- Use `/submit-deal` for the deterministic deal intake flow; it creates a deal only after the user reviews the answers and the Agent Auth capability is granted.
+- After onboarding, behave like normal Pi unless the user asks for Seed-specific workflows.
+
+The deterministic onboarding and deal submission sequences are available through extension commands, not enforced by this prompt.