prompts-gpt 0.2.8

package/dist/index.js

@@ -0,0 +1,1119 @@
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { ensureGitignoreEntry } from "./runtime.js";
+export { DEFAULT_RUN_ARTIFACTS_DIR, DEFAULT_RUN_CONFIG_PATH, ORCHESTRATION_AGENT_PROFILES, DEFAULT_MODELS, normalizeOrchestrationAgent, normalizeConcreteProvider, loadRunConfig, detectProviders, doctor, initRunConfig, runBatch, runPrompt, resolveRunProvider, resolveTimeoutSeconds, resolveDefaultPromptFile, assertPromptFitsLaunch, warnModelProviderMismatch, executeProviderCommandWithRetries, executeProviderCommand, captureWorktreeStatus, buildWorktreeDelta, buildProviderCommand, formatCombinedOutput, appendFileSafe, aggregateTokenUsage, validateRunConfig, discoverWorkspaceAssets, emptyTokenUsage, extractTokenUsageFromLog, hasTokenUsage, isCI, readTokenUsageFromLog, ensureGitignoreEntry, } from "./runtime.js";
+export { sweepPrompt, acquireSweepLock, releaseSweepLock, parseStreamJsonToolCounts, streamJsonHasResult, extractIterationSummary, buildIterationPrompt, runPreFlight, writeSweepManifest, } from "./sweep.js";
+export const DEFAULT_PROMPTS_GPT_API_URL = "https://prompts-gpt.com";
+export const DEFAULT_PROMPTS_GPT_OUT_DIR = ".prompts-gpt";
+export const PROMPTS_GPT_CREDENTIALS_FILE = ".credentials.json";
+export const PROMPTS_GPT_MANIFEST_FILE = "manifest.json";
+export const SUPPORTED_AGENT_TARGETS = [
+    "codex",
+    "claude-code",
+    "cursor",
+    "vscode",
+    "copilot",
+    "continue",
+    "gemini-cli",
+    "windsurf",
+    "cline",
+    "junie",
+    "amp",
+];
+export class PromptsGptApiError extends Error {
+    status;
+    code;
+    recovery;
+    requestId;
+    fieldErrors;
+    retryAfterMs;
+    constructor(message, options) {
+        super(message);
+        this.name = "PromptsGptApiError";
+        this.status = options?.status ?? 0;
+        this.code = options?.code ?? "UNKNOWN_ERROR";
+        this.recovery = options?.recovery ?? "Retry the request or create a fresh project token.";
+        this.requestId = options?.requestId ?? null;
+        this.fieldErrors = options?.fieldErrors ? Object.freeze({ ...options.fieldErrors }) : undefined;
+        this.retryAfterMs = options?.retryAfterMs ?? null;
+    }
+}
+const DEFAULT_TIMEOUT_MS = 30_000;
+const DEFAULT_GENERATE_TIMEOUT_MS = 60_000;
+const MAX_RETRIES = 2;
+const RETRYABLE_STATUS_CODES = new Set([408, 429, 502, 503, 504]);
+export class PromptsGptClient {
+    apiUrl;
+    token;
+    fetchImpl;
+    timeoutMs;
+    accountId;
+    constructor(options) {
+        this.apiUrl = safeNormalizeApiUrl(options.apiUrl);
+        this.token = options.token?.trim() || null;
+        this.fetchImpl = options.fetch;
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.accountId = options.accountId?.trim() || null;
+        if (this.token && this.apiUrl.startsWith("http://") && !this.apiUrl.includes("localhost") && !this.apiUrl.includes("127.0.0.1")) {
+            throw new PromptsGptApiError("Refusing to send credentials over unencrypted HTTP. Use HTTPS or localhost.", { code: "INSECURE_TRANSPORT", recovery: "Change the API URL to use https://." });
+        }
+    }
+    async getProject(options = {}) {
+        const data = await this.request("/api/sdk/v1/project", options);
+        return data.project;
+    }
+    async pullPrompts(query = {}, options = {}) {
+        const qs = serializePromptQuery(query);
+        const suffix = qs ? `?${qs}` : "";
+        const data = await this.request(`/api/sdk/v1/prompts${suffix}`, options);
+        if (!Array.isArray(data.prompts)) {
+            throw new PromptsGptApiError("Prompts-GPT returned an invalid prompts payload.", {
+                code: "INVALID_RESPONSE",
+                recovery: "Retry the request. If it keeps failing, verify the SDK API version.",
+            });
+        }
+        return data.prompts;
+    }
+    async fetchModels(options = {}) {
+        const suffix = options.provider ? `?provider=${encodeURIComponent(options.provider)}` : "";
+        try {
+            const data = await this.request(`/api/sdk/v1/models${suffix}`, options);
+            return data.models ?? {};
+        }
+        catch (err) {
+            if (err instanceof PromptsGptApiError && err.status === 404) {
+                return {};
+            }
+            throw err;
+        }
+    }
+    async generatePrompt(input, options = {}) {
+        const trimmedGoal = input.goal?.trim() ?? "";
+        if (trimmedGoal.length < 8) {
+            throw new PromptsGptApiError("Goal must be at least 8 characters.", { code: "VALIDATION_ERROR" });
+        }
+        if (trimmedGoal.length > 160) {
+            throw new PromptsGptApiError("Goal must be 160 characters or fewer.", { code: "VALIDATION_ERROR" });
+        }
+        const trimmedContext = input.context?.trim() ?? "";
+        if (trimmedContext.length > 1600) {
+            throw new PromptsGptApiError("Context must be 1600 characters or fewer.", { code: "VALIDATION_ERROR" });
+        }
+        const trimmedConstraints = input.constraints?.trim() ?? "";
+        if (trimmedConstraints.length > 1600) {
+            throw new PromptsGptApiError("Constraints must be 1600 characters or fewer.", { code: "VALIDATION_ERROR" });
+        }
+        const trimmedDesiredOutput = input.desiredOutput?.trim() ?? "";
+        if (trimmedDesiredOutput.length > 1600) {
+            throw new PromptsGptApiError("Desired output must be 1600 characters or fewer.", { code: "VALIDATION_ERROR" });
+        }
+        const data = await this.request("/api/sdk/v1/prompts/generate", {
+            method: "POST",
+            body: input,
+            timeoutMs: options.timeoutMs ?? DEFAULT_GENERATE_TIMEOUT_MS,
+            ...options,
+        });
+        return data.prompt;
+    }
+    async request(pathname, options = {}, retryCount = 0) {
+        if (!this.token) {
+            throw new PromptsGptApiError("Project token is missing.", {
+                status: 401,
+                code: "AUTH_ERROR",
+                recovery: "Run `prompts-gpt init --token <token>` or pass `--token`, `--token-stdin`, or `--token-prompt` to the CLI command.",
+            });
+        }
+        if (!this.token.startsWith("pgpt_")) {
+            throw new PromptsGptApiError("Token must start with the 'pgpt_' prefix.", {
+                code: "VALIDATION_ERROR",
+                recovery: "Ensure the token value is copied correctly from the dashboard.",
+            });
+        }
+        const fetchFn = this.fetchImpl;
+        if (typeof fetchFn !== "function") {
+            throw new PromptsGptApiError("A fetch implementation is required. Use Node 18.18+ or pass fetch in the client options.", {
+                code: "MISSING_FETCH",
+            });
+        }
+        const controller = new AbortController();
+        const releaseLinkedAbort = linkAbortSignal(options.signal, controller);
+        const timeoutMs = normalizeTimeoutMs(options.timeoutMs ?? this.timeoutMs);
+        const timeout = setTimeout(() => controller.abort(), timeoutMs);
+        timeout.unref?.();
+        const method = options.method ?? "GET";
+        try {
+            if (options.signal?.aborted) {
+                throw new PromptsGptApiError(`Request to ${pathname} was aborted by the caller.`, {
+                    code: "REQUEST_ABORTED",
+                    recovery: "Start a new request when you are ready to continue.",
+                });
+            }
+            const url = new URL(pathname, this.apiUrl);
+            const headers = {
+                authorization: `Bearer ${this.token}`,
+                accept: "application/json",
+                "x-prompts-gpt-client": `prompts-gpt/${getClientVersion()}`,
+                "x-prompts-gpt-build": getBuildFingerprint(),
+            };
+            if (this.accountId) {
+                headers["x-prompts-gpt-account"] = this.accountId;
+            }
+            if (!options.omitUserAgent) {
+                headers["user-agent"] = `prompts-gpt-client/${getClientVersion()} (${process.platform}; node/${process.version})`;
+            }
+            const outgoingRequestId = options.requestId?.trim() || generateRequestId();
+            headers["x-request-id"] = outgoingRequestId;
+            if (options.body) {
+                headers["content-type"] = "application/json";
+            }
+            const response = await fetchFn(url, {
+                method,
+                headers,
+                body: options.body ? JSON.stringify(options.body) : undefined,
+                signal: controller.signal,
+            });
+            const requestId = response.headers?.get?.("x-request-id") ?? outgoingRequestId;
+            const retryAfterMs = parseRetryAfterHeader(response.headers?.get?.("retry-after"));
+            const contentType = response.headers?.get?.("content-type") ?? "";
+            if (!isJsonContentType(contentType) && response.status !== 204) {
+                throw new PromptsGptApiError(`Unexpected response content-type: ${contentType || "none"}`, {
+                    status: response.status,
+                    code: "INVALID_RESPONSE",
+                    recovery: "Verify the API URL is correct and the server is accessible.",
+                    requestId,
+                    retryAfterMs,
+                });
+            }
+            const payload = await parseJsonResponse(response);
+            const apiResponse = parseApiResponse(payload);
+            if (!response.ok || !apiResponse || !apiResponse.ok) {
+                if (!apiResponse) {
+                    throw new PromptsGptApiError("Prompts-GPT returned an unexpected API envelope.", {
+                        status: response.status,
+                        code: "INVALID_RESPONSE",
+                        recovery: "Retry the request. If it keeps failing, verify the SDK API version.",
+                        requestId,
+                        retryAfterMs,
+                    });
+                }
+                if (shouldRetryRequest({ method, status: response.status, retryCount, retryAfterMs })) {
+                    await sleep(computeRetryDelayMs(retryCount, retryAfterMs));
+                    return this.request(pathname, options, retryCount + 1);
+                }
+                const error = !apiResponse.ok ? apiResponse.error : null;
+                throw new PromptsGptApiError(error?.message ?? `Prompts-GPT request failed with ${response.status}.`, {
+                    status: response.status,
+                    code: error?.code,
+                    recovery: error?.recovery,
+                    requestId,
+                    retryAfterMs,
+                    fieldErrors: error?.fieldErrors,
+                });
+            }
+            return apiResponse.data;
+        }
+        catch (error) {
+            if (error instanceof PromptsGptApiError)
+                throw error;
+            if (!options.omitUserAgent && isUserAgentRuntimeError(error)) {
+                return this.request(pathname, { ...options, omitUserAgent: true }, retryCount);
+            }
+            if (error?.name === "AbortError") {
+                if (options.signal?.aborted) {
+                    throw new PromptsGptApiError(`Request to ${pathname} was aborted by the caller.`, {
+                        code: "REQUEST_ABORTED",
+                        recovery: "Start a new request when you are ready to continue.",
+                    });
+                }
+                throw new PromptsGptApiError(`Request to ${pathname} timed out after ${timeoutMs}ms.`, {
+                    code: "TIMEOUT",
+                    recovery: "Check your network connection or increase the timeout.",
+                });
+            }
+            if (retryCount < MAX_RETRIES && method === "GET" && isNetworkError(error)) {
+                await sleep(computeRetryDelayMs(retryCount));
+                return this.request(pathname, options, retryCount + 1);
+            }
+            throw new PromptsGptApiError(error?.message ?? "Network request failed.", {
+                code: "NETWORK_ERROR",
+                recovery: "Check your network connection and retry.",
+            });
+        }
+        finally {
+            releaseLinkedAbort();
+            clearTimeout(timeout);
+        }
+    }
+}
+function isNetworkError(error) {
+    if (!error)
+        return false;
+    const name = String(error.name ?? "").toLowerCase();
+    const message = String(error.message ?? "").toLowerCase();
+    return (name === "typeerror" ||
+        message.includes("fetch") ||
+        message.includes("network") ||
+        message.includes("econnrefused") ||
+        message.includes("enotfound") ||
+        message.includes("eai_again") ||
+        message.includes("ecancelled") ||
+        message.includes("socket"));
+}
+function isUserAgentRuntimeError(error) {
+    const message = String(error?.message ?? "").toLowerCase();
+    return message.includes("user-agent") && message.includes("not allowed");
+}
+function linkAbortSignal(signal, controller) {
+    if (!signal)
+        return () => undefined;
+    if (signal.aborted) {
+        controller.abort(signal.reason);
+        return () => undefined;
+    }
+    const abort = () => controller.abort(signal.reason);
+    signal.addEventListener("abort", abort, { once: true });
+    return () => signal.removeEventListener("abort", abort);
+}
+function normalizeTimeoutMs(value) {
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new PromptsGptApiError("Timeout must be a positive number of milliseconds.", {
+            code: "VALIDATION_ERROR",
+            recovery: "Provide a timeout greater than 0.",
+        });
+    }
+    const MAX_API_TIMEOUT_MS = 600_000;
+    const capped = Math.min(Math.trunc(value), MAX_API_TIMEOUT_MS);
+    return capped;
+}
+function serializePromptQuery(query) {
+    const params = new URLSearchParams();
+    const promptQuery = typeof query.query === "string" && query.query.trim() ? query.query : query.q;
+    if (typeof promptQuery === "string" && promptQuery.trim()) {
+        params.set("q", promptQuery.trim());
+    }
+    for (const [key, value] of Object.entries({
+        category: query.category,
+        tool: query.tool,
+        outputType: query.outputType,
+    })) {
+        if (typeof value === "string" && value.trim()) {
+            params.set(key, value.trim());
+        }
+    }
+    if (query.limit !== undefined && query.limit !== null && query.limit !== "") {
+        const limit = typeof query.limit === "string" ? Number(query.limit) : query.limit;
+        if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
+            throw new PromptsGptApiError("Prompt limit must be an integer between 1 and 100.", {
+                code: "VALIDATION_ERROR",
+                recovery: "Choose a limit between 1 and 100.",
+            });
+        }
+        params.set("limit", String(limit));
+    }
+    return params.toString();
+}
+function isJsonContentType(contentType) {
+    const normalized = contentType.toLowerCase();
+    return normalized.includes("application/json") || normalized.includes("+json");
+}
+async function parseJsonResponse(response) {
+    if (response.status === 204)
+        return { ok: true, data: {} };
+    const rawBody = await response.text();
+    if (!rawBody.trim())
+        return null;
+    try {
+        return JSON.parse(rawBody);
+    }
+    catch {
+        throw new PromptsGptApiError("Prompts-GPT returned malformed JSON.", {
+            status: response.status,
+            code: "INVALID_RESPONSE",
+            recovery: "Retry the request. If it keeps failing, verify the API URL and server health.",
+            requestId: response.headers?.get?.("x-request-id") ?? null,
+        });
+    }
+}
+function parseApiResponse(payload) {
+    if (!payload || typeof payload !== "object" || !("ok" in payload))
+        return null;
+    if (payload.ok === true && "data" in payload) {
+        return payload;
+    }
+    if (payload.ok === false && "error" in payload) {
+        return payload;
+    }
+    return null;
+}
+function shouldRetryRequest({ method, status, retryCount, retryAfterMs, }) {
+    if (retryCount >= MAX_RETRIES)
+        return false;
+    if (!RETRYABLE_STATUS_CODES.has(status))
+        return false;
+    if (retryAfterMs !== null && retryAfterMs > 300_000)
+        return false;
+    if (method !== "GET")
+        return false;
+    return true;
+}
+function computeRetryDelayMs(retryCount, retryAfterMs = null) {
+    const baseDelay = retryAfterMs && retryAfterMs > 0 ? retryAfterMs : (retryCount + 1) * 1_000;
+    const jitter = Math.random() * 500;
+    return Math.min(baseDelay + jitter, 30_000);
+}
+function parseRetryAfterHeader(value) {
+    if (!value)
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    const seconds = Number(trimmed);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+        const ms = seconds * 1_000;
+        return Math.min(ms, 600_000);
+    }
+    const retryAt = Date.parse(trimmed);
+    if (Number.isNaN(retryAt))
+        return null;
+    return Math.min(Math.max(retryAt - Date.now(), 0), 600_000);
+}
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function generateRequestId() {
+    try {
+        const crypto = globalThis.crypto;
+        const bytes = new Uint8Array(8);
+        crypto.getRandomValues(bytes);
+        return `pgcli_${Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("")}`;
+    }
+    catch {
+        const hex = Array.from({ length: 8 }, () => Math.floor(Math.random() * 256).toString(16).padStart(2, "0")).join("");
+        return `pgcli_${hex}`;
+    }
+}
+const BUILD_TS = "dev";
+const BUILD_ACCOUNT_ID = "unattributed";
+let cachedBuildFingerprint = null;
+function getBuildFingerprint() {
+    if (cachedBuildFingerprint)
+        return cachedBuildFingerprint;
+    const ts = BUILD_TS === "dev" ? "local" : BUILD_TS;
+    const acct = BUILD_ACCOUNT_ID === "unattributed" ? "local" : BUILD_ACCOUNT_ID;
+    cachedBuildFingerprint = `${getClientVersion()}/${ts}/${acct}`;
+    return cachedBuildFingerprint;
+}
+export function getAttribution() {
+    return {
+        version: getClientVersion(),
+        buildTs: BUILD_TS,
+        accountId: BUILD_ACCOUNT_ID,
+    };
+}
+let cachedVersion = null;
+function getClientVersion() {
+    if (cachedVersion)
+        return cachedVersion;
+    try {
+        const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+        cachedVersion = pkg.version ?? "0.0.0";
+    }
+    catch {
+        cachedVersion = "0.0.0";
+    }
+    return cachedVersion;
+}
+export async function saveLocalCredentials(input) {
+    const trimmedToken = input.token?.trim();
+    if (!trimmedToken)
+        throw new Error("Token is required.");
+    if (trimmedToken.length > 256)
+        throw new Error("Token value is too long.");
+    if (!trimmedToken.startsWith("pgpt_"))
+        throw new Error("Token must start with the 'pgpt_' prefix.");
+    const cwd = input.cwd ?? process.cwd();
+    const outDir = path.resolve(cwd, DEFAULT_PROMPTS_GPT_OUT_DIR);
+    await mkdir(outDir, { recursive: true });
+    const credentialsPath = path.join(outDir, PROMPTS_GPT_CREDENTIALS_FILE);
+    const credContent = `${JSON.stringify({ token: trimmedToken, apiUrl: normalizeApiUrl(input.apiUrl ?? DEFAULT_PROMPTS_GPT_API_URL) }, null, 2)}\n`;
+    if (process.platform === "win32") {
+        await writeFile(credentialsPath, credContent);
+    }
+    else {
+        await writeFile(credentialsPath, credContent, { mode: 0o600 });
+        await chmod(credentialsPath, 0o600).catch(() => undefined);
+    }
+    await ensureGitignoreEntry(cwd, `${DEFAULT_PROMPTS_GPT_OUT_DIR}/${PROMPTS_GPT_CREDENTIALS_FILE}`);
+    return { credentialsPath };
+}
+export async function loadLocalCredentials(cwd = process.cwd()) {
+    const credentialsPath = path.resolve(cwd, DEFAULT_PROMPTS_GPT_OUT_DIR, PROMPTS_GPT_CREDENTIALS_FILE);
+    if (!existsSync(credentialsPath))
+        return null;
+    try {
+        const raw = await readFile(credentialsPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object")
+            return null;
+        let apiUrl = DEFAULT_PROMPTS_GPT_API_URL;
+        if (typeof parsed.apiUrl === "string") {
+            try {
+                const url = new URL(parsed.apiUrl);
+                if (url.protocol === "https:" || url.protocol === "http:") {
+                    apiUrl = parsed.apiUrl;
+                }
+            }
+            catch { /* invalid URL — use default */ }
+        }
+        const rawToken = typeof parsed.token === "string" ? parsed.token.trim() : null;
+        if (rawToken && !rawToken.startsWith("pgpt_")) {
+            return { token: null, apiUrl };
+        }
+        return {
+            token: rawToken || null,
+            apiUrl,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function syncPrompts(prompts, options = {}) {
+    const markdown = await writePromptMarkdownFiles(prompts, options);
+    const agents = await writeAgentFiles(prompts, {
+        cwd: options.cwd,
+        agent: options.agent,
+        agents: options.agents,
+        overwriteAgentFiles: options.overwrite,
+    });
+    const manifest = await writePromptManifest(prompts, { cwd: options.cwd, outDir: options.outDir });
+    return { markdown, agents, manifest };
+}
+export async function writePromptMarkdownFiles(prompts, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const outDir = assertSafeOutputDir(cwd, options.outDir ?? DEFAULT_PROMPTS_GPT_OUT_DIR);
+    const overwrite = Boolean(options.overwrite);
+    const normalizedPrompts = assertUniquePromptFileStems(prompts);
+    await mkdir(outDir, { recursive: true });
+    const written = [];
+    const skipped = [];
+    for (const { prompt, stem } of normalizedPrompts) {
+        if (/\.\.|[/\\]/.test(stem))
+            throw new Error(`Invalid prompt stem: ${stem}`);
+        const filePath = path.join(outDir, `${stem}.md`);
+        assertInside(filePath, outDir);
+        if (overwrite) {
+            await writeFile(filePath, formatPromptMarkdown(prompt));
+            written.push(filePath);
+        }
+        else {
+            try {
+                await writeFile(filePath, formatPromptMarkdown(prompt), { flag: "wx" });
+                written.push(filePath);
+            }
+            catch (err) {
+                if (err.code === "EEXIST") {
+                    skipped.push(filePath);
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+    }
+    await writePromptIndex(prompts, { outDir });
+    return { outDir, written, skipped };
+}
+export async function writeAgentFiles(prompts, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    if (!existsSync(cwd)) {
+        throw new Error(`Working directory does not exist: ${cwd}`);
+    }
+    const targets = normalizeAgentTargets(options.agent ?? options.agents ?? "all");
+    const overwrite = Boolean(options.overwriteAgentFiles);
+    const written = [];
+    const skipped = [];
+    const normalizedPrompts = assertUniquePromptFileStems(prompts);
+    const allFiles = targets.flatMap((target) => buildAgentFiles(target, normalizedPrompts.filter(({ prompt }) => promptSupportsAgentTarget(prompt, target))).map((file) => ({ ...file, target })));
+    assertUniqueAgentFilePaths(allFiles);
+    const dirSet = new Set(allFiles.map((file) => path.dirname(assertSafeProjectFile(cwd, file.path))));
+    await Promise.all([...dirSet].map((dir) => mkdir(dir, { recursive: true })));
+    for (const file of allFiles) {
+        const filePath = assertSafeProjectFile(cwd, file.path);
+        if (file.managedBlock) {
+            let existing = "";
+            try {
+                existing = await readFile(filePath, "utf8");
+            }
+            catch { }
+            await writeFile(filePath, upsertManagedBlock(existing, file.content));
+            written.push(filePath);
+            continue;
+        }
+        if (overwrite) {
+            await writeFile(filePath, file.content);
+            written.push(filePath);
+        }
+        else {
+            try {
+                await writeFile(filePath, file.content, { flag: "wx" });
+                written.push(filePath);
+            }
+            catch (err) {
+                if (err.code === "EEXIST") {
+                    skipped.push(filePath);
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+    }
+    return { written, skipped, targets };
+}
+export async function writePromptManifest(prompts, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const outDir = assertSafeOutputDir(cwd, options.outDir ?? DEFAULT_PROMPTS_GPT_OUT_DIR);
+    const normalizedPrompts = assertUniquePromptFileStems(prompts);
+    await mkdir(outDir, { recursive: true });
+    const manifestPath = path.join(outDir, PROMPTS_GPT_MANIFEST_FILE);
+    const attribution = getAttribution();
+    const payload = {
+        version: 1,
+        generatedAt: new Date().toISOString(),
+        generatedBy: `prompts-gpt@${attribution.version}`,
+        accountId: attribution.accountId,
+        buildFingerprint: `${attribution.version}/${attribution.accountId}`,
+        count: normalizedPrompts.length,
+        prompts: normalizedPrompts.map(({ prompt, stem }) => ({
+            slug: stem,
+            title: prompt.title,
+            summary: prompt.summary ?? "",
+            source: prompt.source ?? "library",
+            category: prompt.category ?? "Prompt Library",
+            difficulty: prompt.difficulty ?? "Intermediate",
+            outputType: prompt.outputType ?? "Text",
+            supportedTools: prompt.supportedTools ?? [],
+            agentTargets: normalizePromptAgentTargets(prompt),
+            variables: prompt.variables ?? [],
+            tags: prompt.tags ?? [],
+            recommendedPath: prompt.recommendedPath ?? null,
+            file: `${stem}.md`,
+            files: buildDiscoverablePromptFiles(stem, prompt),
+        })),
+    };
+    await writeFile(manifestPath, `${JSON.stringify(payload, null, 2)}\n`);
+    return { manifestPath, manifest: payload };
+}
+export function formatPromptMarkdown(prompt) {
+    return [
+        "---",
+        `title: ${yamlScalar(prompt.title)}`,
+        `slug: ${yamlScalar(prompt.slug)}`,
+        `source: ${yamlScalar(prompt.source ?? "library")}`,
+        `category: ${yamlScalar(prompt.category ?? "Prompt Library")}`,
+        `difficulty: ${yamlScalar(prompt.difficulty ?? "Intermediate")}`,
+        `outputType: ${yamlScalar(prompt.outputType ?? "Text")}`,
+        `supportedTools: [${(prompt.supportedTools ?? []).map(yamlScalar).join(", ")}]`,
+        `tags: [${(prompt.tags ?? []).map(yamlScalar).join(", ")}]`,
+        "---",
+        "",
+        `# ${prompt.title}`,
+        "",
+        prompt.summary ?? "",
+        "",
+        "## Prompt",
+        "",
+        prompt.promptText ?? "",
+        "",
+        ...(prompt.variables?.length ? ["## Variables", "", ...prompt.variables.map((variable) => `- \`${variable}\``), ""] : []),
+        ...(prompt.usageNotes ? ["## Usage Notes", "", prompt.usageNotes] : []),
+        "",
+    ].reduce((acc, line, index, list) => {
+        if (line === "" && index > 0 && list[index - 1] === "" && (index < 2 || list[index - 2] === ""))
+            return acc;
+        acc.push(line);
+        return acc;
+    }, []).join("\n");
+}
+function buildAgentFiles(target, prompts) {
+    if (target === "codex") {
+        return [{
+                path: "AGENTS.md",
+                managedBlock: true,
+                content: [
+                    "# Prompts-GPT Agent Instructions",
+                    "",
+                    "Prompts synced by `prompts-gpt sync` live in `.prompts-gpt/`. Start with [.prompts-gpt/manifest.json](.prompts-gpt/manifest.json), then open the prompt packs linked below before starting related work.",
+                    "",
+                    "## Available Prompt Packs",
+                    ...prompts.map(({ prompt, stem }) => `- [${prompt.title}](.prompts-gpt/${stem}.md)`),
+                    "",
+                    "When a prompt pack is relevant, load it, adapt variables to the current task, and keep verification tied to the prompt's acceptance criteria.",
+                    "",
+                ].join("\n"),
+            }];
+    }
+    if (target === "claude-code") {
+        return [{
+                path: "CLAUDE.md",
+                managedBlock: true,
+                content: [
+                    "# Prompts-GPT Claude Code Instructions",
+                    "",
+                    "Prompts synced by `prompts-gpt sync` live in `.prompts-gpt/`. Start with [.prompts-gpt/manifest.json](.prompts-gpt/manifest.json), then open the prompt packs linked below before starting related work.",
+                    "",
+                    "## Available Prompt Packs",
+                    ...prompts.map(({ prompt, stem }) => `- [${prompt.title}](.prompts-gpt/${stem}.md)`),
+                    "",
+                    "When a prompt pack is relevant, load it, adapt variables to the current task, and keep verification tied to the prompt's acceptance criteria.",
+                    "",
+                ].join("\n"),
+            }];
+    }
+    if (target === "cursor") {
+        return prompts.flatMap(({ prompt, stem }) => ([
+            {
+                path: `.cursor/rules/prompts-gpt-${stem}.mdc`,
+                content: [
+                    "---",
+                    `description: ${yamlScalar(prompt.summary || prompt.title)}`,
+                    "globs: []",
+                    "alwaysApply: false",
+                    "---",
+                    "",
+                    `# ${prompt.title}`,
+                    "",
+                    prompt.promptText,
+                    "",
+                    prompt.usageNotes ? `Usage notes: ${prompt.usageNotes}` : "",
+                    "",
+                ].filter(Boolean).join("\n"),
+            },
+            {
+                path: `.cursor/commands/prompts-gpt-${stem}.md`,
+                content: formatCursorCommandMarkdown(prompt, stem),
+            },
+        ]));
+    }
+    if (target === "vscode") {
+        return [
+            {
+                path: ".github/copilot-instructions.md",
+                managedBlock: true,
+                content: [
+                    "# Prompts-GPT Copilot Instructions",
+                    "",
+                    "Use [../.prompts-gpt/manifest.json](../.prompts-gpt/manifest.json) and the linked `.prompts-gpt/*.md` prompt packs as reusable repository context.",
+                    "",
+                    ...prompts.map(({ prompt, stem }) => `- [${prompt.title}](../.prompts-gpt/${stem}.md)`),
+                    "",
+                ].join("\n"),
+            },
+            {
+                path: ".github/instructions/prompts-gpt.instructions.md",
+                content: [
+                    "---",
+                    'applyTo: "AGENTS.md,.prompts-gpt/**/*.md,.github/copilot-instructions.md,.github/prompts/**/*.prompt.md,.cursor/rules/**/*.mdc,.cursor/commands/**/*.md,.vscode/prompts-gpt.code-snippets"',
+                    "---",
+                    "",
+                    "# Prompts-GPT managed artifacts",
+                    "",
+                    "These files are generated or refreshed by `prompts-gpt sync`.",
+                    "",
+                    "- Treat `.prompts-gpt/manifest.json` as the source of truth for discoverable prompt packs and generated agent files.",
+                    "- Prefer updating the upstream prompt pack or rerunning sync instead of manually editing generated agent artifacts.",
+                    "- Preserve the managed `prompts-gpt` blocks inside `AGENTS.md` and `.github/copilot-instructions.md`.",
+                    "",
+                ].join("\n"),
+            },
+            {
+                path: ".vscode/prompts-gpt.code-snippets",
+                content: JSON.stringify(buildVsCodeSnippets(prompts), null, 2) + "\n",
+            },
+        ];
+    }
+    if (target === "copilot") {
+        return prompts.map(({ prompt, stem }) => ({
+            path: `.github/prompts/prompts-gpt-${stem}.prompt.md`,
+            content: formatCopilotPromptMarkdown(prompt, stem),
+        }));
+    }
+    if (target === "continue") {
+        return prompts.map(({ prompt, stem }) => ({
+            path: `.continue/rules/prompts-gpt-${stem}.md`,
+            content: [
+                `# ${prompt.title}`,
+                "",
+                `[Canonical prompt pack](../../.prompts-gpt/${stem}.md)`,
+                "",
+                prompt.summary ?? "",
+                "",
+                prompt.promptText ?? "",
+                "",
+                prompt.usageNotes ? `Usage notes: ${prompt.usageNotes}` : "",
+                "",
+            ].filter(Boolean).join("\n"),
+        }));
+    }
+    if (target === "gemini-cli") {
+        return [{
+                path: "GEMINI.md",
+                managedBlock: true,
+                content: [
+                    "# Prompts-GPT Gemini CLI Instructions",
+                    "",
+                    "Prompts synced by `prompts-gpt sync` live in `.prompts-gpt/`. Start with [.prompts-gpt/manifest.json](.prompts-gpt/manifest.json), then open the prompt packs linked below before starting related work.",
+                    "",
+                    "## Available Prompt Packs",
+                    ...prompts.map(({ prompt, stem }) => `- [${prompt.title}](.prompts-gpt/${stem}.md)`),
+                    "",
+                    "When a prompt pack is relevant, load it, adapt variables to the current task, and keep verification tied to the prompt's acceptance criteria.",
+                    "",
+                ].join("\n"),
+            }];
+    }
+    if (target === "windsurf") {
+        return prompts.map(({ prompt, stem }) => ({
+            path: `.windsurf/rules/prompts-gpt-${stem}.md`,
+            content: [
+                `# ${prompt.title}`,
+                "",
+                `[Canonical prompt pack](../../.prompts-gpt/${stem}.md)`,
+                "",
+                prompt.summary ?? "",
+                "",
+                prompt.promptText ?? "",
+                "",
+                "Use this as a workspace rule for Cascade or Devin Local when the prompt pack matches the task.",
+                prompt.usageNotes ? `Usage notes: ${prompt.usageNotes}` : "",
+                "",
+            ].filter(Boolean).join("\n"),
+        }));
+    }
+    if (target === "cline") {
+        return prompts.map(({ prompt, stem }) => ({
+            path: `.clinerules/prompts-gpt-${stem}.md`,
+            content: [
+                `# ${prompt.title}`,
+                "",
+                `[Canonical prompt pack](../.prompts-gpt/${stem}.md)`,
+                "",
+                prompt.summary ?? "",
+                "",
+                prompt.promptText ?? "",
+                "",
+                "Enable this rule when the current Cline task matches the linked prompt pack.",
+                prompt.usageNotes ? `Usage notes: ${prompt.usageNotes}` : "",
+                "",
+            ].filter(Boolean).join("\n"),
+        }));
+    }
+    if (target === "junie") {
+        return [{
+                path: ".junie/guidelines.md",
+                managedBlock: true,
+                content: [
+                    "# Prompts-GPT Junie Guidelines",
+                    "",
+                    "Prompts synced by `prompts-gpt sync` live in `.prompts-gpt/`. Start with [.prompts-gpt/manifest.json](.prompts-gpt/manifest.json), then open the prompt packs linked below before starting related work.",
+                    "",
+                    "## Available Prompt Packs",
+                    ...prompts.map(({ prompt, stem }) => `- [${prompt.title}](../.prompts-gpt/${stem}.md)`),
+                    "",
+                    "When a prompt pack is relevant, load it, adapt variables to the current task, and keep verification tied to the prompt's acceptance criteria.",
+                    "",
+                ].join("\n"),
+            }];
+    }
+    if (target === "amp") {
+        return [{
+                path: "AGENT.md",
+                managedBlock: true,
+                content: [
+                    "# Prompts-GPT Amp Instructions",
+                    "",
+                    "Prompts synced by `prompts-gpt sync` live in `.prompts-gpt/`. Start with [.prompts-gpt/manifest.json](.prompts-gpt/manifest.json), then open the prompt packs linked below before starting related work.",
+                    "",
+                    "## Available Prompt Packs",
+                    ...prompts.map(({ prompt, stem }) => `- [${prompt.title}](.prompts-gpt/${stem}.md)`),
+                    "",
+                    "When a prompt pack is relevant, load it, adapt variables to the current task, and keep verification tied to the prompt's acceptance criteria.",
+                    "",
+                ].join("\n"),
+            }];
+    }
+    return [];
+}
+function buildVsCodeSnippets(prompts) {
+    return prompts.reduce((snippets, { prompt, stem }) => {
+        snippets[`Prompts-GPT: ${prompt.title}`] = {
+            prefix: `pgpt-${stem}`,
+            description: prompt.summary || prompt.title,
+            body: String(prompt.promptText || "").split(/\r?\n/),
+        };
+        return snippets;
+    }, {});
+}
+function normalizePromptAgentTargets(prompt) {
+    const validSet = new Set(SUPPORTED_AGENT_TARGETS);
+    const declaredTargets = Array.isArray(prompt.agentTargets)
+        ? prompt.agentTargets.map((target) => String(target).trim().toLowerCase()).filter(Boolean)
+        : [];
+    return [...new Set(declaredTargets.filter((target) => validSet.has(target)))];
+}
+function promptSupportsAgentTarget(prompt, target) {
+    const declaredTargets = normalizePromptAgentTargets(prompt);
+    return declaredTargets.length === 0 || declaredTargets.includes(target);
+}
+function assertUniquePromptFileStems(prompts) {
+    const byStem = new Map();
+    const normalizedPrompts = prompts.map((prompt) => {
+        const stem = safeSlug(prompt.slug || prompt.title);
+        const matches = byStem.get(stem) ?? [];
+        matches.push(prompt);
+        byStem.set(stem, matches);
+        return { prompt, stem };
+    });
+    const collisions = [...byStem.entries()].filter(([, items]) => items.length > 1);
+    if (collisions.length > 0) {
+        const details = collisions
+            .map(([stem, items]) => `${stem} <- ${items.map((item) => item.title || item.slug || "Untitled prompt").join(", ")}`)
+            .join("; ");
+        throw new Error(`Refusing to sync prompts with colliding file names after slug normalization: ${details}`);
+    }
+    return normalizedPrompts;
+}
+function assertUniqueAgentFilePaths(files) {
+    const pathCounts = new Map();
+    for (const file of files) {
+        const targets = pathCounts.get(file.path) ?? [];
+        targets.push(file.target);
+        pathCounts.set(file.path, targets);
+    }
+    const collisions = [...pathCounts.entries()].filter(([, targets]) => targets.length > 1 && !targets.every((target) => target === targets[0]));
+    if (collisions.length > 0) {
+        const details = collisions.map(([filePath, targets]) => `${filePath} <- ${targets.join(", ")}`).join("; ");
+        throw new Error(`Refusing to sync duplicate agent file paths: ${details}`);
+    }
+}
+function buildDiscoverablePromptFiles(stem, prompt) {
+    const agentTargets = new Set(normalizePromptAgentTargets(prompt));
+    const supports = (target) => agentTargets.size === 0 || agentTargets.has(target);
+    return {
+        markdown: `.prompts-gpt/${stem}.md`,
+        codexInstructions: supports("codex") ? "AGENTS.md" : null,
+        claudeCodeInstructions: supports("claude-code") ? "CLAUDE.md" : null,
+        cursorRule: supports("cursor") ? `.cursor/rules/prompts-gpt-${stem}.mdc` : null,
+        cursorCommand: supports("cursor") ? `.cursor/commands/prompts-gpt-${stem}.md` : null,
+        vscodeInstructions: supports("vscode") ? ".github/copilot-instructions.md" : null,
+        copilotPathInstructions: supports("vscode") ? ".github/instructions/prompts-gpt.instructions.md" : null,
+        vscodeSnippets: supports("vscode") ? ".vscode/prompts-gpt.code-snippets" : null,
+        copilotPrompt: supports("copilot") ? `.github/prompts/prompts-gpt-${stem}.prompt.md` : null,
+        continueRule: supports("continue") ? `.continue/rules/prompts-gpt-${stem}.md` : null,
+        geminiInstructions: supports("gemini-cli") ? "GEMINI.md" : null,
+        windsurfRule: supports("windsurf") ? `.windsurf/rules/prompts-gpt-${stem}.md` : null,
+        clineRule: supports("cline") ? `.clinerules/prompts-gpt-${stem}.md` : null,
+        junieGuidelines: supports("junie") ? ".junie/guidelines.md" : null,
+        ampInstructions: supports("amp") ? "AGENT.md" : null,
+    };
+}
+function formatCursorCommandMarkdown(prompt, stem) {
+    const lines = [
+        `# ${prompt.title}`,
+        "",
+        `[Canonical prompt pack](../../.prompts-gpt/${stem}.md)`,
+        "",
+        prompt.summary ?? "",
+        "",
+        "## Task",
+        "",
+        prompt.promptText ?? "",
+    ];
+    if (prompt.variables?.length) {
+        lines.push("", "## Inputs", "");
+        for (const variable of prompt.variables) {
+            lines.push(`- ${String(variable).replace(/[{}$]/g, "")}`);
+        }
+    }
+    if (prompt.usageNotes) {
+        lines.push("", "## Usage Notes", "", prompt.usageNotes);
+    }
+    lines.push("", "Verify the output against `.prompts-gpt/manifest.json` and the linked canonical prompt pack.", "");
+    return lines
+        .reduce((acc, line, index, list) => {
+        if (line === "" && index > 0 && list[index - 1] === "" && (index < 2 || list[index - 2] === ""))
+            return acc;
+        acc.push(line);
+        return acc;
+    }, [])
+        .join("\n");
+}
+function formatCopilotPromptMarkdown(prompt, stem) {
+    const sections = [
+        "---",
+        "mode: agent",
+        `description: ${yamlScalar(prompt.summary || prompt.title)}`,
+        "---",
+        "",
+        `# ${prompt.title}`,
+        "",
+        `Use [../../.prompts-gpt/${stem}.md](../../.prompts-gpt/${stem}.md) as the canonical prompt-pack reference and verify generated work against [../../.prompts-gpt/manifest.json](../../.prompts-gpt/manifest.json).`,
+        "",
+        prompt.summary ?? "",
+        "",
+        "## Task",
+        "",
+        prompt.promptText ?? "",
+    ];
+    if (prompt.variables?.length) {
+        sections.push("", "## Inputs", "");
+        for (const variable of prompt.variables) {
+            const sanitizedName = safeSlug(variable) || "value";
+            const sanitizedLabel = String(variable).replace(/[{}$]/g, "");
+            sections.push(`- ${sanitizedLabel}: \${input:${sanitizedName}:Provide ${sanitizedLabel}}`);
+        }
+    }
+    if (prompt.usageNotes) {
+        sections.push("", "## Usage Notes", "", prompt.usageNotes);
+    }
+    sections.push("");
+    return sections
+        .reduce((acc, line, index, list) => {
+        if (line === "" && index > 0 && list[index - 1] === "" && (index < 2 || list[index - 2] === ""))
+            return acc;
+        acc.push(line);
+        return acc;
+    }, [])
+        .join("\n");
+}
+function upsertManagedBlock(existing, content) {
+    const start = "<!-- prompts-gpt:start -->";
+    const end = "<!-- prompts-gpt:end -->";
+    const sanitizedContent = content.trim()
+        .replace(/<!-- prompts-gpt:start -->/g, "")
+        .replace(/<!-- prompts-gpt:end -->/g, "");
+    const block = `${start}\n${sanitizedContent}\n${end}`;
+    const pattern = new RegExp(`${escapeRegExp(start)}[\\s\\S]*?${escapeRegExp(end)}`);
+    if (pattern.test(existing)) {
+        return `${existing.replace(pattern, block).trimEnd()}\n`;
+    }
+    const prefix = existing.trimEnd();
+    return `${prefix ? `${prefix}\n\n` : ""}${block}\n`;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function escapeMarkdownLinkText(value) {
+    return value.replace(/[[\]]/g, "\\$&");
+}
+async function writePromptIndex(prompts, { outDir }) {
+    const indexPath = path.resolve(outDir, "README.md");
+    assertInside(indexPath, path.resolve(outDir));
+    const managedContent = [
+        "# Prompts-GPT Prompt Packs",
+        "",
+        "These prompts were synced by `prompts-gpt`. Re-run `prompts-gpt sync` to refresh Markdown and agent files.",
+        "",
+        "## Prompts",
+        ...prompts.map((prompt) => {
+            const agentTargets = normalizePromptAgentTargets(prompt);
+            const suffix = agentTargets.length ? ` Targets: ${agentTargets.join(", ")}.` : "";
+            const escapedTitle = escapeMarkdownLinkText(prompt.title);
+            return `- [${escapedTitle}](./${safeSlug(prompt.slug || prompt.title)}.md) - ${prompt.summary ?? ""}${suffix}`;
+        }),
+        "",
+    ].join("\n");
+    let existing = "";
+    try {
+        existing = await readFile(indexPath, "utf8");
+    }
+    catch { }
+    await writeFile(indexPath, upsertManagedBlock(existing, managedContent));
+}
+function normalizeAgentTargets(value) {
+    const raw = Array.isArray(value) ? value.join(",") : String(value ?? "all");
+    const targets = raw.split(",").map((item) => item.trim().toLowerCase()).filter(Boolean);
+    if (targets.includes("all"))
+        return [...SUPPORTED_AGENT_TARGETS];
+    const unique = [...new Set(targets)];
+    if (unique.length === 0)
+        return [...SUPPORTED_AGENT_TARGETS];
+    const validSet = new Set(SUPPORTED_AGENT_TARGETS);
+    const invalid = unique.filter((target) => !validSet.has(target));
+    if (invalid.length)
+        throw new Error(`Unsupported agent target: ${invalid.join(", ")}. Use ${SUPPORTED_AGENT_TARGETS.join(", ")}, or all.`);
+    return unique;
+}
+function normalizeApiUrl(value) {
+    const url = new URL(value);
+    if (url.protocol !== "https:" && url.protocol !== "http:") {
+        throw new Error(`API URL must use https or http, got ${url.protocol}`);
+    }
+    url.pathname = "/";
+    url.search = "";
+    url.hash = "";
+    return url.toString().replace(/\/+$/, "");
+}
+function safeNormalizeApiUrl(value) {
+    try {
+        return normalizeApiUrl(value);
+    }
+    catch {
+        throw new PromptsGptApiError(`Invalid API URL: ${value}`, {
+            code: "INVALID_URL",
+            recovery: `Provide a valid URL like ${DEFAULT_PROMPTS_GPT_API_URL}.`,
+        });
+    }
+}
+function isInsideDirectory(child, parent) {
+    const normalizedParent = parent.endsWith(path.sep) ? parent : `${parent}${path.sep}`;
+    return child.startsWith(normalizedParent) || child === parent;
+}
+function assertSafeOutputDir(cwd, outDir) {
+    const root = path.resolve(cwd);
+    const resolved = path.resolve(root, outDir);
+    if (!isInsideDirectory(resolved, root) || resolved === root) {
+        throw new Error("Output directory must be a subdirectory of the current project.");
+    }
+    return resolved;
+}
+function assertSafeProjectFile(cwd, filePath) {
+    const root = path.resolve(cwd);
+    const resolved = path.resolve(root, filePath);
+    if (!isInsideDirectory(resolved, root) || resolved === root) {
+        throw new Error("Agent file path must stay inside the current project.");
+    }
+    return resolved;
+}
+function assertInside(filePath, directory) {
+    if (!isInsideDirectory(filePath, directory) || filePath === directory) {
+        throw new Error("Refusing to write outside the prompt output directory.");
+    }
+}
+function safeSlug(value) {
+    const raw = String(value ?? "").trim();
+    if (!raw)
+        return "prompt";
+    const slug = raw
+        .toLowerCase()
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 90);
+    if (!slug || slug === "-")
+        return "prompt";
+    return slug;
+}
+function yamlScalar(value) {
+    const s = String(value ?? "");
+    if (s.includes("\n") || s.includes("\r")) {
+        return JSON.stringify(s.replace(/\r\n?/g, "\n"));
+    }
+    return JSON.stringify(s);
+}
+//# sourceMappingURL=index.js.map