promptpilot 0.1.0

package/dist/cli.js

@@ -0,0 +1,1543 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { pathToFileURL } from "url";
+
+// src/errors.ts
+var InvalidPromptError = class extends Error {
+  constructor(message = "Prompt must be a non-empty string.") {
+    super(message);
+    this.name = "InvalidPromptError";
+  }
+};
+var OllamaUnavailableError = class extends Error {
+  constructor(message = "Ollama is unavailable or returned an invalid response.") {
+    super(message);
+    this.name = "OllamaUnavailableError";
+  }
+};
+var ContextStoreError = class extends Error {
+  constructor(message = "Context store operation failed.") {
+    super(message);
+    this.name = "ContextStoreError";
+  }
+};
+var TokenBudgetExceededError = class extends Error {
+  constructor(message = "Final prompt could not be reduced to fit within the configured token budget.") {
+    super(message);
+    this.name = "TokenBudgetExceededError";
+  }
+};
+
+// src/storage/fileSessionStore.ts
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join } from "path";
+
+// src/utils/validation.ts
+function normalizeWhitespace(value) {
+  return value.replace(/\r\n/g, "\n").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function validatePrompt(prompt) {
+  if (typeof prompt !== "string" || normalizeWhitespace(prompt).length === 0) {
+    throw new InvalidPromptError();
+  }
+  return normalizeWhitespace(prompt);
+}
+function sanitizeSessionId(sessionId) {
+  return sessionId.trim().replace(/[^a-zA-Z0-9._-]/g, "-");
+}
+
+// src/storage/fileSessionStore.ts
+var FileSessionStore = class {
+  rootDir;
+  constructor(rootDir = join(homedir(), ".promptpilot", "sessions")) {
+    this.rootDir = rootDir;
+  }
+  async loadSession(sessionId) {
+    const filePath = this.getFilePath(sessionId);
+    try {
+      const contents = await readFile(filePath, "utf8");
+      const parsed = JSON.parse(contents);
+      return parsed;
+    } catch (error) {
+      const code = error.code;
+      if (code === "ENOENT") {
+        return this.createEmptySession(sessionId);
+      }
+      throw new ContextStoreError(`Failed to load session "${sessionId}".`);
+    }
+  }
+  async saveSession(session) {
+    const filePath = this.getFilePath(session.sessionId);
+    try {
+      await mkdir(dirname(filePath), { recursive: true });
+      await writeFile(filePath, JSON.stringify(session, null, 2), "utf8");
+    } catch {
+      throw new ContextStoreError(`Failed to save session "${session.sessionId}".`);
+    }
+  }
+  async clearSession(sessionId) {
+    const filePath = this.getFilePath(sessionId);
+    try {
+      await rm(filePath, { force: true });
+    } catch {
+      throw new ContextStoreError(`Failed to clear session "${sessionId}".`);
+    }
+  }
+  getFilePath(sessionId) {
+    return join(this.rootDir, `${sanitizeSessionId(sessionId)}.json`);
+  }
+  createEmptySession(sessionId) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      sessionId,
+      entries: [],
+      summaries: [],
+      createdAt: now,
+      updatedAt: now
+    };
+  }
+};
+
+// src/storage/sqliteSessionStore.ts
+import { dirname as dirname2, join as join2 } from "path";
+import { mkdir as mkdir2 } from "fs/promises";
+var SQLiteSessionStore = class {
+  constructor(dbPath = join2(process.cwd(), ".promptpilot", "promptpilot.db")) {
+    this.dbPath = dbPath;
+    this.dbPromise = this.openDatabase();
+  }
+  dbPath;
+  dbPromise;
+  async loadSession(sessionId) {
+    const db = await this.dbPromise;
+    const row = db.prepare("SELECT data FROM sessions WHERE id = ?").get(sessionId);
+    if (!row?.data) {
+      return createEmptySession(sessionId);
+    }
+    return JSON.parse(row.data);
+  }
+  async saveSession(session) {
+    const db = await this.dbPromise;
+    db.prepare("INSERT OR REPLACE INTO sessions (id, data) VALUES (?, ?)").run(
+      session.sessionId,
+      JSON.stringify(session)
+    );
+  }
+  async clearSession(sessionId) {
+    const db = await this.dbPromise;
+    db.prepare("DELETE FROM sessions WHERE id = ?").run(sessionId);
+  }
+  async openDatabase() {
+    try {
+      await mkdir2(dirname2(this.dbPath), { recursive: true });
+      const nodeSqliteName = "node:sqlite";
+      const nodeSqlite = await import(nodeSqliteName).catch(() => null);
+      if (nodeSqlite?.DatabaseSync) {
+        const db = new nodeSqlite.DatabaseSync(this.dbPath);
+        db.exec("CREATE TABLE IF NOT EXISTS sessions (id TEXT PRIMARY KEY, data TEXT NOT NULL)");
+        return db;
+      }
+      const betterSqliteName = "better-sqlite3";
+      const betterSqlite = await import(betterSqliteName).catch(() => null);
+      if (betterSqlite?.default) {
+        const db = new betterSqlite.default(this.dbPath);
+        db.exec("CREATE TABLE IF NOT EXISTS sessions (id TEXT PRIMARY KEY, data TEXT NOT NULL)");
+        return db;
+      }
+      throw new ContextStoreError(
+        "SQLite store requires node:sqlite support or the better-sqlite3 package."
+      );
+    } catch (error) {
+      if (error instanceof ContextStoreError) {
+        throw error;
+      }
+      throw new ContextStoreError("Failed to initialize SQLite session store.");
+    }
+  }
+};
+function createEmptySession(sessionId) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    sessionId,
+    entries: [],
+    summaries: [],
+    createdAt: now,
+    updatedAt: now
+  };
+}
+
+// src/utils/logger.ts
+var noopLogger = {
+  debug: () => void 0,
+  info: () => void 0,
+  warn: () => void 0,
+  error: () => void 0
+};
+function createLogger(debugEnabled = false) {
+  return {
+    debug(message, meta) {
+      if (debugEnabled) {
+        console.debug(`[promptpilot] ${message}`, meta ?? "");
+      }
+    },
+    info(message, meta) {
+      if (debugEnabled) {
+        console.info(`[promptpilot] ${message}`, meta ?? "");
+      }
+    },
+    warn(message, meta) {
+      if (debugEnabled) {
+        console.warn(`[promptpilot] ${message}`, meta ?? "");
+      }
+    },
+    error(message, meta) {
+      if (debugEnabled) {
+        console.error(`[promptpilot] ${message}`, meta ?? "");
+      }
+    }
+  };
+}
+
+// src/utils/json.ts
+function safeJsonParse(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+function extractFirstJsonObject(value) {
+  const start = value.indexOf("{");
+  if (start === -1) {
+    return null;
+  }
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let index = start; index < value.length; index += 1) {
+    const char = value[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) {
+      continue;
+    }
+    if (char === "{") {
+      depth += 1;
+    } else if (char === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return value.slice(start, index + 1);
+      }
+    }
+  }
+  return null;
+}
+function toPrettyJson(value) {
+  return JSON.stringify(value, null, 2);
+}
+
+// src/core/ollamaClient.ts
+var OllamaClient = class {
+  host;
+  model;
+  timeoutMs;
+  temperature;
+  logger;
+  constructor(config = {}) {
+    this.host = config.host ?? "http://localhost:11434";
+    this.model = config.model ?? "qwen2.5:3b";
+    this.timeoutMs = config.timeoutMs ?? 3e4;
+    this.temperature = config.temperature ?? 0.1;
+    this.logger = config.logger ?? noopLogger;
+  }
+  async isAvailable() {
+    try {
+      const response = await fetch(new URL("/api/tags", this.host), {
+        method: "GET"
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  async listModels() {
+    try {
+      const response = await fetch(new URL("/api/tags", this.host), {
+        method: "GET"
+      });
+      if (!response.ok) {
+        throw new OllamaUnavailableError(`Ollama tags request failed with status ${response.status}.`);
+      }
+      const data = await response.json();
+      return (data.models ?? []).filter((model) => typeof model.name === "string" && model.name.length > 0).map((model) => ({
+        name: model.name,
+        sizeBytes: model.size,
+        family: model.details?.family,
+        parameterSize: model.details?.parameter_size,
+        modifiedAt: model.modified_at
+      }));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown Ollama tags error.";
+      this.logger.warn("ollama.list_models.failed", { message });
+      throw new OllamaUnavailableError(message);
+    }
+  }
+  async generate(options) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? this.timeoutMs);
+    try {
+      const response = await fetch(new URL("/api/generate", this.host), {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          model: options.model ?? this.model,
+          system: options.systemPrompt,
+          prompt: options.prompt,
+          stream: false,
+          format: options.format === "json" ? "json" : void 0,
+          options: {
+            temperature: options.temperature ?? this.temperature
+          }
+        }),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new OllamaUnavailableError(`Ollama request failed with status ${response.status}.`);
+      }
+      const data = await response.json();
+      if (!data.response || typeof data.response !== "string") {
+        throw new OllamaUnavailableError("Ollama did not return a text response.");
+      }
+      return data.response.trim();
+    } catch (error) {
+      if (error instanceof OllamaUnavailableError) {
+        throw error;
+      }
+      const message = error instanceof Error ? error.message : "Unknown Ollama error.";
+      this.logger.warn("ollama.generate.failed", { message });
+      throw new OllamaUnavailableError(message);
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async generateJson(options) {
+    const raw = await this.generate({
+      ...options,
+      format: "json"
+    });
+    const direct = safeJsonParse(raw);
+    if (direct) {
+      return direct;
+    }
+    const extracted = extractFirstJsonObject(raw);
+    if (extracted) {
+      const parsed = safeJsonParse(extracted);
+      if (parsed) {
+        return parsed;
+      }
+    }
+    throw new OllamaUnavailableError("Ollama returned JSON that could not be parsed.");
+  }
+};
+
+// src/core/systemPrompt.ts
+var modeGuidance = {
+  clarity: "Improve clarity, remove ambiguity, and keep the request easy for a downstream model to follow.",
+  concise: "Minimize token count while preserving user intent, constraints, and expected output.",
+  detailed: "Make the request explicit and complete, including structure and success criteria.",
+  structured: "Organize the request into clean sections with compact headings and bullet points where helpful.",
+  persuasive: "Refine wording so the request is compelling and likely to elicit a thoughtful response.",
+  compress: "Aggressively compress redundant wording while preserving the meaning and critical constraints.",
+  claude_cli: "Optimize specifically for Claude CLI: compact sections, direct instructions, and minimal boilerplate."
+};
+var presetGuidance = {
+  code: "Favor precise technical requirements, edge cases, and expected output format for code tasks.",
+  email: "Preserve the sender's goal, tone, and audience; aim for a realistic and usable writing request.",
+  essay: "Preserve thesis, structure, and voice guidance while making the prompt clearer.",
+  support: "Favor concise issue context, user impact, and desired resolution details.",
+  summarization: "Favor strong compression while retaining key facts, structure, and takeaways.",
+  chat: "Keep the prompt natural and conversational while preserving instructions and context."
+};
+function getOptimizationSystemPrompt(mode, preset) {
+  return [
+    "You are PromptPilot, a local prompt optimizer for downstream LLM workflows.",
+    "Return strict JSON only with this shape:",
+    '{"optimizedPrompt":"string","constraints":["string"],"changes":["string"],"warnings":["string"]}',
+    "Rules:",
+    "- Do not change the user's intent.",
+    "- Do not invent new requirements.",
+    "- Preserve critical constraints and task goals.",
+    "- Improve clarity, structure, and downstream usefulness.",
+    "- Keep the result compact when the mode requests compression.",
+    `Mode guidance: ${modeGuidance[mode]}`,
+    preset ? `Preset guidance: ${presetGuidance[preset]}` : "Preset guidance: none"
+  ].join("\n");
+}
+function buildOptimizationPrompt(input, relevantContext, extractedConstraints) {
+  const payload = {
+    prompt: input.prompt,
+    task: input.task ?? null,
+    tone: input.tone ?? null,
+    targetModel: input.targetModel ?? "claude",
+    outputFormat: input.outputFormat ?? null,
+    maxLength: input.maxLength ?? null,
+    mode: input.mode ?? "claude_cli",
+    preset: input.preset ?? null,
+    pinnedConstraints: input.pinnedConstraints ?? [],
+    extractedConstraints,
+    relevantContext
+  };
+  return `Optimize this prompt payload for a downstream LLM.
+${JSON.stringify(payload, null, 2)}`;
+}
+
+// src/core/tokenEstimator.ts
+var TokenEstimator = class {
+  estimateText(text) {
+    const normalized = normalizeWhitespace(text);
+    if (!normalized) {
+      return 0;
+    }
+    const wordCount = normalized.split(/\s+/).length;
+    const charCount = normalized.length;
+    return Math.max(1, Math.ceil(wordCount * 1.3), Math.ceil(charCount / 4));
+  }
+  estimateUsage(input) {
+    const prompt = this.estimateText(input.prompt);
+    const context = this.estimateText(input.context ?? "");
+    return {
+      prompt,
+      context,
+      total: prompt + context
+    };
+  }
+  truncateToBudget(text, tokenBudget) {
+    const normalized = normalizeWhitespace(text);
+    if (tokenBudget <= 0 || !normalized) {
+      return "";
+    }
+    if (this.estimateText(normalized) <= tokenBudget) {
+      return normalized;
+    }
+    const words = normalized.split(/\s+/);
+    const selected = [];
+    for (const word of words) {
+      const candidate = [...selected, word].join(" ");
+      if (this.estimateText(candidate) > tokenBudget) {
+        break;
+      }
+      selected.push(word);
+    }
+    return selected.join(" ").trim();
+  }
+};
+
+// src/core/contextCompressor.ts
+import { randomUUID } from "crypto";
+var ContextCompressor = class {
+  constructor(estimator, client, logger = noopLogger) {
+    this.estimator = estimator;
+    this.client = client;
+    this.logger = logger;
+  }
+  estimator;
+  client;
+  logger;
+  async summarizeEntries(options) {
+    if (options.entries.length === 0 || options.budgetTokens <= 0) {
+      return null;
+    }
+    const ollamaSummary = await this.tryOllamaSummary(options);
+    if (ollamaSummary) {
+      return ollamaSummary;
+    }
+    return this.heuristicSummary(options);
+  }
+  async tryOllamaSummary(options) {
+    if (!this.client || options.entries.length < 3) {
+      return null;
+    }
+    try {
+      const source = options.entries.slice(-8).map((entry) => [
+        `Timestamp: ${entry.timestamp}`,
+        entry.task ? `Task: ${entry.task}` : "",
+        entry.constraints?.length ? `Constraints: ${entry.constraints.join("; ")}` : "",
+        `Prompt: ${entry.rawPrompt ?? entry.text}`
+      ].filter(Boolean).join("\n")).join("\n\n");
+      const response = await this.client.generateJson({
+        systemPrompt: getOptimizationSystemPrompt("compress"),
+        prompt: `Summarize this stored prompt context for reuse in later turns.
+Prompt: ${options.prompt}
+Task: ${options.task ?? "unknown"}
+Budget tokens: ${options.budgetTokens}
+
+${source}`,
+        timeoutMs: options.timeoutMs,
+        format: "json"
+      });
+      const summaryText = this.estimator.truncateToBudget(response.optimizedPrompt ?? "", options.budgetTokens);
+      if (!summaryText) {
+        return null;
+      }
+      return {
+        id: randomUUID(),
+        sessionId: options.sessionId,
+        text: summaryText,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        sourceEntryIds: options.entries.map((entry) => entry.id),
+        tokenEstimate: this.estimator.estimateText(summaryText),
+        kind: "ollama"
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown summary failure";
+      this.logger.debug("context.summary.ollama_fallback", { message });
+      return null;
+    }
+  }
+  heuristicSummary(options) {
+    const constraints = Array.from(
+      new Set(options.entries.flatMap((entry) => entry.constraints ?? []).filter(Boolean))
+    ).slice(0, 6);
+    const recentPrompts = options.entries.slice(-4).map((entry) => `- ${truncateLine(entry.rawPrompt ?? entry.text, 120)}`);
+    const lines = [
+      constraints.length ? `Key constraints: ${constraints.join("; ")}` : "",
+      recentPrompts.length ? `Recent focus:
+${recentPrompts.join("\n")}` : ""
+    ].filter(Boolean);
+    const summaryText = this.estimator.truncateToBudget(lines.join("\n\n"), options.budgetTokens);
+    return {
+      id: randomUUID(),
+      sessionId: options.sessionId,
+      text: summaryText,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      sourceEntryIds: options.entries.map((entry) => entry.id),
+      tokenEstimate: this.estimator.estimateText(summaryText),
+      kind: "heuristic"
+    };
+  }
+};
+function truncateLine(value, maxLength) {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return `${value.slice(0, maxLength - 3).trim()}...`;
+}
+
+// src/core/contextManager.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var ContextManager = class {
+  constructor(store, estimator, compressor, logger = noopLogger) {
+    this.store = store;
+    this.estimator = estimator;
+    this.compressor = compressor;
+    this.logger = logger;
+  }
+  store;
+  estimator;
+  compressor;
+  logger;
+  async loadContext(sessionId) {
+    return this.store.loadSession(sessionId);
+  }
+  async clearContext(sessionId) {
+    await this.store.clearSession(sessionId);
+  }
+  async saveContext(options) {
+    const session = await this.store.loadSession(options.sessionId);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const constraints = Array.from(
+      /* @__PURE__ */ new Set([
+        ...extractConstraints(options.input.prompt),
+        ...options.input.pinnedConstraints ?? []
+      ])
+    );
+    const entry = {
+      id: randomUUID2(),
+      sessionId: options.sessionId,
+      text: options.optimizedPrompt,
+      rawPrompt: options.input.prompt,
+      optimizedPrompt: options.optimizedPrompt,
+      finalPrompt: options.finalPrompt,
+      task: options.input.task,
+      tone: options.input.tone,
+      tags: options.input.tags ?? [],
+      constraints,
+      entities: extractEntities(options.input.prompt),
+      pinned: (options.input.pinnedConstraints?.length ?? 0) > 0,
+      timestamp,
+      tokenEstimate: this.estimator.estimateText(options.finalPrompt)
+    };
+    session.entries.push(entry);
+    if (session.entries.length > 100) {
+      session.entries = session.entries.slice(-100);
+    }
+    if (options.contextSummary) {
+      session.summaries.push(options.contextSummary);
+      if (session.summaries.length > 10) {
+        session.summaries = session.summaries.slice(-10);
+      }
+    }
+    session.updatedAt = timestamp;
+    await this.store.saveSession(session);
+  }
+  async summarizeContext(sessionId, prompt, task, budgetTokens, timeoutMs) {
+    const session = await this.store.loadSession(sessionId);
+    if (session.entries.length === 0) {
+      return null;
+    }
+    return this.compressor.summarizeEntries({
+      sessionId,
+      entries: session.entries,
+      prompt,
+      task,
+      budgetTokens,
+      timeoutMs
+    });
+  }
+  async getRelevantContext(options) {
+    const session = await this.store.loadSession(options.sessionId);
+    if (session.entries.length === 0 && session.summaries.length === 0) {
+      return {
+        usedEntries: [],
+        summary: null,
+        warnings: [],
+        debugInfo: { scores: [] }
+      };
+    }
+    const scores = session.entries.map((entry, index) => ({
+      entry,
+      score: scoreEntry({
+        entry,
+        prompt: options.prompt,
+        task: options.task,
+        tags: options.tags,
+        pinnedConstraints: options.pinnedConstraints,
+        index,
+        total: session.entries.length
+      })
+    }));
+    const selected = [];
+    const seenFingerprints = /* @__PURE__ */ new Set();
+    let selectedTokens = 0;
+    for (const scored of scores.sort((left, right) => right.score - left.score)) {
+      if (selected.find((entry) => entry.id === scored.entry.id)) {
+        continue;
+      }
+      const fingerprint = createFingerprint(scored.entry);
+      if (seenFingerprints.has(fingerprint)) {
+        continue;
+      }
+      if (selectedTokens + scored.entry.tokenEstimate > options.maxContextTokens) {
+        continue;
+      }
+      selected.push(scored.entry);
+      seenFingerprints.add(fingerprint);
+      selectedTokens += scored.entry.tokenEstimate;
+    }
+    const remainder = session.entries.filter(
+      (entry) => !selected.find((selectedEntry) => selectedEntry.id === entry.id)
+    );
+    let summary = null;
+    if (remainder.length > 1 && selectedTokens < Math.floor(options.maxContextTokens * 0.8)) {
+      summary = await this.compressor.summarizeEntries({
+        sessionId: options.sessionId,
+        entries: remainder,
+        prompt: options.prompt,
+        task: options.task,
+        budgetTokens: Math.max(80, options.maxContextTokens - selectedTokens),
+        timeoutMs: options.timeoutMs
+      });
+    } else if (session.summaries.length > 0) {
+      const latest = session.summaries.at(-1) ?? null;
+      if (latest && latest.tokenEstimate <= options.maxContextTokens - selectedTokens) {
+        summary = latest;
+      }
+    }
+    const warnings = [];
+    if (remainder.length > 0) {
+      warnings.push(`Dropped ${remainder.length} lower-value context item(s) to fit the token budget.`);
+    }
+    return {
+      usedEntries: selected.sort((left, right) => left.timestamp.localeCompare(right.timestamp)),
+      summary,
+      warnings,
+      debugInfo: {
+        scores: scores.sort((left, right) => right.score - left.score).map(({ entry, score }) => ({ id: entry.id, score, task: entry.task, timestamp: entry.timestamp }))
+      }
+    };
+  }
+};
+function scoreEntry(input) {
+  const promptTerms = tokenize(input.prompt);
+  const promptEntities = new Set(extractEntities(input.prompt).map((entity) => entity.toLowerCase()));
+  const entryTerms = tokenize(
+    [input.entry.rawPrompt, input.entry.optimizedPrompt, input.entry.constraints?.join(" ")].filter(Boolean).join(" ")
+  );
+  const entryEntities = new Set((input.entry.entities ?? []).map((entity) => entity.toLowerCase()));
+  const overlap = Array.from(promptTerms).filter((term) => entryTerms.has(term)).length;
+  const entityOverlap = Array.from(promptEntities).filter((entity) => entryEntities.has(entity)).length;
+  const taskMatch = input.task && input.entry.task === input.task ? 2 : 0;
+  const pinned = input.entry.pinned ? 3 : 0;
+  const pinnedConstraintMatch = Array.from(new Set(input.pinnedConstraints ?? [])).filter(
+    (constraint) => (input.entry.constraints ?? []).includes(constraint)
+  ).length;
+  const tagOverlap = Array.from(new Set(input.tags ?? [])).filter((tag) => (input.entry.tags ?? []).includes(tag)).length;
+  const constraintBonus = (input.entry.constraints?.length ?? 0) > 0 ? 0.75 : 0;
+  const recency = (input.index + 1) / input.total;
+  return overlap * 0.8 + entityOverlap * 1.2 + taskMatch + pinned + pinnedConstraintMatch * 2 + tagOverlap + constraintBonus + recency;
+}
+function tokenize(value) {
+  return new Set(
+    value.toLowerCase().split(/[^a-z0-9]+/i).filter((token) => token.length > 2)
+  );
+}
+function extractConstraints(value) {
+  return value.split(/\n+/).map((line) => line.trim()).filter((line) => /(must|should|avoid|do not|don't|never|exactly|at most|under|limit|max)/i.test(line)).slice(0, 8);
+}
+function extractEntities(value) {
+  return Array.from(
+    new Set(value.match(/\b[A-Z][a-zA-Z0-9._-]+\b/g) ?? [])
+  ).slice(0, 12);
+}
+function createFingerprint(entry) {
+  return [entry.task ?? "", entry.rawPrompt ?? entry.text].join("::").toLowerCase().replace(/\s+/g, " ").trim();
+}
+
+// src/core/modelSelector.ts
+var DEFAULT_SMALL_MODEL_PREFERENCES = [
+  "qwen2.5:3b",
+  "phi3:mini",
+  "llama3.2:3b",
+  "qwen2.5:1.5b"
+];
+function getDefaultPreferredModels() {
+  return [...DEFAULT_SMALL_MODEL_PREFERENCES];
+}
+function selectOllamaModel(input) {
+  const preferred = buildPreferredOrder(input);
+  const smallCandidates = input.installedModels.filter((model) => isSuitableSmallModel(model));
+  const preferredMatch = findPreferredMatch(smallCandidates, preferred);
+  if (preferredMatch) {
+    return {
+      model: preferredMatch,
+      reason: `Selected installed model "${preferredMatch}" from the preferred low-memory order.`,
+      suitableForAutoUse: true
+    };
+  }
+  const ranked = [...smallCandidates].filter((model) => isUsefulGenerationModel(model.name)).map((model) => ({ model, score: scoreModel(model.name, input.preset, input.mode, input.task) })).sort((left, right) => right.score - left.score);
+  if (ranked[0]) {
+    return {
+      model: ranked[0].model.name,
+      reason: `Selected installed model "${ranked[0].model.name}" using task-aware ranking.`,
+      suitableForAutoUse: true
+    };
+  }
+  const oversizedRanked = [...input.installedModels].filter((model) => isUsefulGenerationModel(model.name)).map((model) => ({ model, score: scoreModel(model.name, input.preset, input.mode, input.task) })).sort((left, right) => right.score - left.score);
+  if (oversizedRanked[0]) {
+    return {
+      model: oversizedRanked[0].model.name,
+      reason: `Installed model "${oversizedRanked[0].model.name}" was detected, but it is larger than the preferred low-memory range for auto-use.`,
+      suitableForAutoUse: false
+    };
+  }
+  return {
+    model: preferred[0] ?? "qwen2.5:3b",
+    reason: "No installed Ollama models were discovered, so the default small-model preference was used.",
+    suitableForAutoUse: false
+  };
+}
+function buildPreferredOrder(input) {
+  const taskContext = `${input.task ?? ""} ${input.preset} ${input.mode}`.toLowerCase();
+  const configured = (input.preferredModels ?? []).map((model) => model.toLowerCase());
+  if (taskContext.includes("code")) {
+    return uniqueModels([
+      ...configured,
+      "qwen2.5-coder:3b",
+      "qwen2.5:3b",
+      "phi3:mini",
+      "llama3.2:3b",
+      "qwen2.5:1.5b"
+    ]);
+  }
+  if (taskContext.includes("compress") || taskContext.includes("summar")) {
+    return uniqueModels([
+      ...configured,
+      "qwen2.5:3b",
+      "qwen2.5:1.5b",
+      "phi3:mini",
+      "llama3.2:3b"
+    ]);
+  }
+  return uniqueModels([...configured, ...DEFAULT_SMALL_MODEL_PREFERENCES]);
+}
+function uniqueModels(models) {
+  return Array.from(new Set(models));
+}
+function findPreferredMatch(installedModels, preferred) {
+  const installedNames = installedModels.map((model) => model.name);
+  for (const preferredName of preferred) {
+    const direct = installedNames.find((name) => name.toLowerCase() === preferredName);
+    if (direct) {
+      return direct;
+    }
+  }
+  return null;
+}
+function scoreModel(modelName, preset, mode, task) {
+  const lower = modelName.toLowerCase();
+  let score = 0;
+  if (!isUsefulGenerationModel(lower)) {
+    return -100;
+  }
+  if (lower.includes("qwen2.5")) {
+    score += 4;
+  } else if (lower.includes("phi3")) {
+    score += 3.5;
+  } else if (lower.includes("llama3.2")) {
+    score += 3;
+  } else if (lower.includes("mistral")) {
+    score += 2;
+  }
+  const parameterSize = extractBillions(lower);
+  if (parameterSize !== null) {
+    if (parameterSize <= 4) {
+      score += 4;
+    } else if (parameterSize <= 8) {
+      score += 1;
+    } else {
+      score -= 4;
+    }
+  }
+  if (lower.includes("mini")) {
+    score += 2;
+  }
+  if (lower.includes("instruct") || lower.includes("chat")) {
+    score += 1;
+  }
+  const taskContext = `${task ?? ""} ${preset} ${mode}`.toLowerCase();
+  if (taskContext.includes("code") && lower.includes("coder")) {
+    score += 3;
+  }
+  if ((taskContext.includes("compress") || taskContext.includes("summar")) && lower.includes("qwen2.5")) {
+    score += 1;
+  }
+  return score;
+}
+function extractBillions(modelName) {
+  const match = modelName.match(/(\d+(?:\.\d+)?)b/);
+  if (!match) {
+    return null;
+  }
+  return Number.parseFloat(match[1]);
+}
+function isUsefulGenerationModel(modelName) {
+  const lower = modelName.toLowerCase();
+  return ![
+    "embed",
+    "embedding",
+    "whisper",
+    "vision",
+    "diffusion",
+    "tts",
+    "bge",
+    "nomic-embed"
+  ].some((blocked) => lower.includes(blocked));
+}
+function isSuitableSmallModel(model) {
+  if (!isUsefulGenerationModel(model.name)) {
+    return false;
+  }
+  const byParameter = extractBillions(`${model.parameterSize ?? ""} ${model.name}`);
+  if (byParameter !== null) {
+    return byParameter <= 4;
+  }
+  if (typeof model.sizeBytes === "number") {
+    return model.sizeBytes <= 55e8;
+  }
+  return /mini|1\.5b|2b|3b|4b/i.test(model.name);
+}
+
+// src/core/optimizer.ts
+var DEFAULT_MODE = "claude_cli";
+var DEFAULT_PRESET = "chat";
+var DEFAULT_PROVIDER = "ollama";
+var DEFAULT_MAX_INPUT_TOKENS = 1200;
+var DEFAULT_MAX_CONTEXT_TOKENS = 800;
+var DEFAULT_MAX_TOTAL_TOKENS = 2200;
+var PromptOptimizer = class {
+  config;
+  logger;
+  estimator;
+  client;
+  compressor;
+  contextManager;
+  constructor(config = {}) {
+    this.logger = config.logger ?? noopLogger;
+    this.estimator = new TokenEstimator();
+    this.client = config.ollamaClient ?? new OllamaClient({
+      host: config.host,
+      model: config.ollamaModel,
+      timeoutMs: config.timeoutMs,
+      temperature: config.temperature,
+      logger: this.logger
+    });
+    const store = resolveSessionStore(config);
+    this.compressor = new ContextCompressor(this.estimator, this.client, this.logger);
+    this.contextManager = new ContextManager(store, this.estimator, this.compressor, this.logger);
+    this.config = {
+      ...config,
+      host: config.host ?? "http://localhost:11434",
+      ollamaModel: config.ollamaModel,
+      preferredModels: config.preferredModels ?? getDefaultPreferredModels(),
+      timeoutMs: config.timeoutMs ?? 3e4,
+      temperature: config.temperature ?? 0.1
+    };
+  }
+  async optimize(input) {
+    const originalPrompt = validatePrompt(input.prompt);
+    const mode = input.mode ?? this.config.defaultMode ?? DEFAULT_MODE;
+    const preset = input.preset ?? this.config.defaultPreset ?? DEFAULT_PRESET;
+    const maxInputTokens = input.maxInputTokens ?? this.config.maxInputTokens ?? DEFAULT_MAX_INPUT_TOKENS;
+    const maxContextTokens = input.maxContextTokens ?? this.config.maxContextTokens ?? DEFAULT_MAX_CONTEXT_TOKENS;
+    const maxTotalTokens = input.maxTotalTokens ?? this.config.maxTotalTokens ?? DEFAULT_MAX_TOTAL_TOKENS;
+    const warnings = [];
+    const changes = [];
+    const useContext = input.useContext !== false && Boolean(input.sessionId);
+    const saveContext = input.saveContext ?? Boolean(input.sessionId);
+    const relevantContext = useContext && input.sessionId ? await this.contextManager.getRelevantContext({
+      sessionId: input.sessionId,
+      prompt: originalPrompt,
+      task: input.task,
+      tags: input.tags,
+      pinnedConstraints: input.pinnedConstraints,
+      maxContextTokens,
+      timeoutMs: input.timeoutMs ?? this.config.timeoutMs
+    }) : emptyRelevantContext();
+    warnings.push(...relevantContext.warnings);
+    const contextBlock = formatContextBlock(relevantContext);
+    const estimatedTokensBefore = this.estimator.estimateUsage({
+      prompt: originalPrompt,
+      context: contextBlock
+    });
+    if (estimatedTokensBefore.prompt > maxInputTokens) {
+      warnings.push(
+        `Raw prompt estimate (${estimatedTokensBefore.prompt}) exceeds maxInputTokens (${maxInputTokens}).`
+      );
+    }
+    const extractedConstraints = Array.from(
+      /* @__PURE__ */ new Set([...extractConstraints(originalPrompt), ...input.pinnedConstraints ?? []])
+    );
+    let provider = input.bypassOptimization ? "heuristic" : this.config.provider ?? DEFAULT_PROVIDER;
+    let model = provider === "ollama" ? this.config.ollamaModel ?? "auto" : "heuristic";
+    let optimizedPrompt = originalPrompt;
+    let providerWarnings = [];
+    let providerChanges = [];
+    if (provider === "ollama") {
+      const modelSelection = await this.resolveOllamaModel({
+        mode,
+        preset,
+        task: input.task
+      });
+      model = modelSelection.model;
+      providerWarnings.push(...modelSelection.warnings);
+      if (input.debug) {
+        changes.push(modelSelection.reason);
+      }
+      if (modelSelection.forceHeuristic) {
+        provider = "heuristic";
+        model = "heuristic";
+      }
+      const ollamaResult = provider === "ollama" ? await this.tryOllamaOptimization({
+        input: {
+          ...input,
+          prompt: originalPrompt,
+          mode,
+          preset
+        },
+        model,
+        extractedConstraints,
+        relevantContext: contextBlock
+      }) : null;
+      if (ollamaResult) {
+        optimizedPrompt = ollamaResult.optimizedPrompt;
+        providerWarnings = ollamaResult.warnings;
+        providerChanges = ollamaResult.changes;
+      } else if (provider === "ollama") {
+        provider = "heuristic";
+        model = "heuristic";
+        providerWarnings = [
+          `Ollama was unavailable. Falling back to deterministic local prompt shaping.`
+        ];
+      }
+    }
+    if (provider === "heuristic") {
+      const fallback = this.heuristicOptimize({
+        input: {
+          ...input,
+          prompt: originalPrompt,
+          mode,
+          preset
+        },
+        context: relevantContext,
+        constraints: extractedConstraints
+      });
+      optimizedPrompt = fallback.optimizedPrompt;
+      providerChanges = [...providerChanges, ...fallback.changes];
+      providerWarnings = [...providerWarnings, ...fallback.warnings];
+    }
+    warnings.push(...providerWarnings);
+    changes.push(...providerChanges);
+    let finalPrompt = composeFinalPrompt({
+      optimizedPrompt,
+      input: {
+        ...input,
+        prompt: originalPrompt,
+        mode,
+        preset
+      },
+      context: relevantContext
+    });
+    let estimatedTokensAfter = {
+      prompt: this.estimator.estimateText(optimizedPrompt),
+      context: this.estimator.estimateText(formatContextBlock(relevantContext)),
+      total: this.estimator.estimateText(finalPrompt)
+    };
+    if (estimatedTokensAfter.total > maxTotalTokens) {
+      const reduced = await this.reduceToBudget({
+        input: {
+          ...input,
+          prompt: originalPrompt,
+          mode,
+          preset
+        },
+        optimizedPrompt,
+        context: relevantContext,
+        maxTotalTokens
+      });
+      finalPrompt = reduced.finalPrompt;
+      estimatedTokensAfter = reduced.estimatedTokensAfter;
+      if (reduced.warning) {
+        warnings.push(reduced.warning);
+      }
+    }
+    if (estimatedTokensAfter.total > maxTotalTokens) {
+      throw new TokenBudgetExceededError();
+    }
+    if (saveContext && input.sessionId) {
+      await this.contextManager.saveContext({
+        sessionId: input.sessionId,
+        input: {
+          ...input,
+          prompt: originalPrompt
+        },
+        optimizedPrompt,
+        finalPrompt,
+        contextSummary: relevantContext.summary
+      });
+    }
+    return {
+      originalPrompt,
+      optimizedPrompt,
+      finalPrompt,
+      usedContext: relevantContext.usedEntries,
+      contextSummary: relevantContext.summary,
+      estimatedTokensBefore,
+      estimatedTokensAfter,
+      tokenSavings: Math.max(0, estimatedTokensBefore.total - estimatedTokensAfter.total),
+      mode,
+      provider,
+      model,
+      warnings,
+      changes,
+      debugInfo: input.debug ? {
+        context: relevantContext.debugInfo,
+        estimatedTokensBefore,
+        estimatedTokensAfter,
+        extractedConstraints,
+        preset,
+        selectedModel: model
+      } : void 0
+    };
+  }
+  async clearContext(sessionId) {
+    await this.contextManager.clearContext(sessionId);
+  }
+  async loadContext(sessionId) {
+    return this.contextManager.loadContext(sessionId);
+  }
+  async summarizeContext(sessionId, prompt, task, budgetTokens = 200) {
+    return this.contextManager.summarizeContext(sessionId, prompt, task, budgetTokens, this.config.timeoutMs);
+  }
+  async getRelevantContext(sessionId, prompt, task, maxContextTokens) {
+    return this.contextManager.getRelevantContext({
+      sessionId,
+      prompt,
+      task,
+      maxContextTokens: maxContextTokens ?? this.config.maxContextTokens ?? DEFAULT_MAX_CONTEXT_TOKENS,
+      timeoutMs: this.config.timeoutMs
+    });
+  }
+  async tryOllamaOptimization(options) {
+    try {
+      if (!await this.client.isAvailable()) {
+        return null;
+      }
+      const response = await this.client.generateJson({
+        systemPrompt: getOptimizationSystemPrompt(options.input.mode, options.input.preset),
+        prompt: buildOptimizationPrompt(options.input, options.relevantContext, options.extractedConstraints),
+        timeoutMs: options.input.timeoutMs ?? this.config.timeoutMs,
+        model: options.model,
+        temperature: this.config.temperature,
+        format: "json"
+      });
+      const optimizedPrompt = normalizeWhitespace(response.optimizedPrompt ?? "");
+      if (!optimizedPrompt) {
+        return null;
+      }
+      return {
+        optimizedPrompt,
+        changes: response.changes ?? [`Applied Ollama optimization with ${options.model}.`],
+        warnings: response.warnings ?? []
+      };
+    } catch {
+      return null;
+    }
+  }
+  async resolveOllamaModel(options) {
+    if (this.config.ollamaModel) {
+      return {
+        model: this.config.ollamaModel,
+        warnings: [],
+        reason: `Using explicitly configured model "${this.config.ollamaModel}".`,
+        forceHeuristic: false
+      };
+    }
+    if (!this.client.listModels) {
+      const fallback = this.config.preferredModels[0] ?? "qwen2.5:3b";
+      return {
+        model: fallback,
+        warnings: [`Model auto-selection is unavailable in the current Ollama client, so "${fallback}" was assumed.`],
+        reason: `Assumed default model "${fallback}" because model discovery is unsupported.`,
+        forceHeuristic: false
+      };
+    }
+    try {
+      const installedModels = await this.client.listModels();
+      const selection = selectOllamaModel({
+        installedModels,
+        mode: options.mode,
+        preset: options.preset,
+        task: options.task,
+        preferredModels: this.config.preferredModels
+      });
+      if (!selection.suitableForAutoUse) {
+        return {
+          model: selection.model,
+          warnings: [
+            `No suitable small Ollama model was found for auto-use. Falling back to heuristic optimization. Install one of: ${this.config.preferredModels.join(", ")}.`,
+            selection.reason
+          ],
+          reason: selection.reason,
+          forceHeuristic: true
+        };
+      }
+      return {
+        model: selection.model,
+        warnings: installedModels.length === 0 ? [`No installed Ollama models were reported, so "${selection.model}" was chosen as the default preference.`] : [],
+        reason: selection.reason,
+        forceHeuristic: false
+      };
+    } catch {
+      const fallback = this.config.preferredModels[0] ?? "qwen2.5:3b";
+      return {
+        model: fallback,
+        warnings: [`Failed to inspect local Ollama models, so "${fallback}" was chosen as the default preference.`],
+        reason: `Fell back to default model "${fallback}" because model discovery failed.`,
+        forceHeuristic: false
+      };
+    }
+  }
+  heuristicOptimize(options) {
+    const lines = [
+      `Request: ${options.input.prompt}`,
+      options.input.task ? `Task type: ${options.input.task}` : "",
+      options.input.tone ? `Tone: ${options.input.tone}` : "",
+      options.input.outputFormat ? `Output format: ${options.input.outputFormat}` : "",
+      options.input.maxLength ? `Maximum length: ${options.input.maxLength}` : "",
+      options.constraints.length ? `Critical constraints: ${options.constraints.join("; ")}` : ""
+    ].filter(Boolean);
+    const optimizedPrompt = lines.join("\n");
+    const changes = ["Normalized prompt structure for downstream model consumption."];
+    if (options.input.mode === "compress" || options.input.mode === "concise") {
+      changes.push("Applied concise formatting to reduce token usage.");
+    }
+    return {
+      optimizedPrompt,
+      changes,
+      warnings: []
+    };
+  }
+  async reduceToBudget(options) {
+    const summaryBudget = Math.max(80, Math.floor(options.maxTotalTokens * 0.2));
+    const summary = options.input.sessionId ? await this.summarizeContext(options.input.sessionId, options.input.prompt, options.input.task, summaryBudget) : null;
+    const compactContext = {
+      ...options.context,
+      usedEntries: [],
+      summary
+    };
+    const finalPrompt = composeFinalPrompt({
+      optimizedPrompt: this.estimator.truncateToBudget(options.optimizedPrompt, Math.floor(options.maxTotalTokens * 0.5)),
+      input: options.input,
+      context: compactContext
+    });
+    return {
+      finalPrompt,
+      estimatedTokensAfter: {
+        prompt: this.estimator.estimateText(options.optimizedPrompt),
+        context: this.estimator.estimateText(formatContextBlock(compactContext)),
+        total: this.estimator.estimateText(finalPrompt)
+      },
+      warning: "Summarized stored context further to stay within the total token budget."
+    };
+  }
+};
+function resolveSessionStore(config) {
+  if (typeof config.contextStore === "object" && config.contextStore !== null) {
+    return config.contextStore;
+  }
+  if (config.contextStore === "sqlite") {
+    return new SQLiteSessionStore(config.sqlitePath);
+  }
+  return new FileSessionStore(config.storageDir);
+}
+function composeFinalPrompt(input) {
+  const sections = [];
+  sections.push(`Task:
+${input.optimizedPrompt}`);
+  const contextBlock = formatContextBlock(input.context);
+  if (contextBlock) {
+    sections.push(`Relevant context:
+${contextBlock}`);
+  }
+  const constraints = Array.from(
+    new Set([
+      ...input.input.pinnedConstraints ?? [],
+      ...extractConstraints(input.input.prompt),
+      input.input.maxLength ? `Keep the response within ${input.input.maxLength} units if possible.` : "",
+      input.input.tone ? `Maintain a ${input.input.tone} tone.` : "",
+      input.input.outputFormat ? `Return the output as ${input.input.outputFormat}.` : ""
+    ].filter(Boolean))
+  );
+  if (constraints.length > 0) {
+    sections.push(`Constraints:
+- ${constraints.join("\n- ")}`);
+  }
+  const desiredOutput = [
+    input.input.targetModel ? `Target model: ${input.input.targetModel}` : "Target model: claude",
+    `Mode: ${input.input.mode}`,
+    `Preset: ${input.input.preset}`
+  ];
+  sections.push(`Desired output:
+- ${desiredOutput.join("\n- ")}`);
+  return sections.join("\n\n").trim();
+}
+function formatContextBlock(context) {
+  const lines = [];
+  if (context.summary?.text) {
+    lines.push(`Summary: ${context.summary.text}`);
+  }
+  for (const entry of context.usedEntries.slice(-4)) {
+    lines.push(`- ${entry.optimizedPrompt ?? entry.rawPrompt ?? entry.text}`);
+  }
+  return normalizeWhitespace(lines.join("\n"));
+}
+function emptyRelevantContext() {
+  return {
+    usedEntries: [],
+    summary: null,
+    warnings: [],
+    debugInfo: {}
+  };
+}
+
+// src/index.ts
+function createOptimizer(config = {}) {
+  return new PromptOptimizer(config);
+}
+
+// src/cli.ts
+async function runCli(argv, io = { stdout: process.stdout, stderr: process.stderr, stdin: process.stdin }, dependencies = { createOptimizer, readStdin }) {
+  const [command, ...rest] = argv;
+  if (!command || command === "--help" || command === "-h") {
+    io.stdout.write(`${getHelpText()}
+`);
+    return 0;
+  }
+  if (command !== "optimize") {
+    io.stderr.write(`Unknown command: ${command}
+`);
+    io.stderr.write(`${getHelpText()}
+`);
+    return 1;
+  }
+  const parsed = parseOptimizeArgs(rest);
+  if (parsed.help) {
+    io.stdout.write(`${getHelpText()}
+`);
+    return 0;
+  }
+  if (!parsed.sessionId && parsed.clearSession) {
+    io.stderr.write("--clear-session requires --session <id>.\n");
+    return 1;
+  }
+  const optimizer = dependencies.createOptimizer({
+    provider: "ollama",
+    ollamaModel: parsed.model,
+    host: parsed.host,
+    contextStore: parsed.contextStore,
+    storageDir: parsed.storageDir,
+    sqlitePath: parsed.sqlitePath,
+    timeoutMs: parsed.timeoutMs,
+    logger: createLogger(parsed.debug)
+  });
+  if (parsed.clearSession && parsed.sessionId) {
+    await optimizer.clearContext(parsed.sessionId);
+    if (!parsed.prompt) {
+      io.stdout.write(`Cleared session ${parsed.sessionId}
+`);
+      return 0;
+    }
+  }
+  if (!parsed.prompt) {
+    const stdinPrompt = await dependencies.readStdin(io.stdin);
+    parsed.prompt = stdinPrompt.trim() || void 0;
+  }
+  if (!parsed.prompt) {
+    io.stderr.write("A prompt is required.\n");
+    return 1;
+  }
+  try {
+    const result = await optimizer.optimize({
+      prompt: parsed.prompt,
+      task: parsed.task,
+      tone: parsed.tone,
+      mode: parsed.mode,
+      preset: parsed.preset,
+      sessionId: parsed.sessionId,
+      saveContext: parsed.saveContext,
+      useContext: parsed.useContext,
+      targetModel: parsed.targetModel ?? "claude",
+      outputFormat: parsed.outputFormat,
+      maxLength: parsed.maxLength,
+      tags: parsed.tags,
+      pinnedConstraints: parsed.pinnedConstraints,
+      debug: parsed.debug,
+      plainOutput: parsed.plain,
+      maxTotalTokens: parsed.maxTotalTokens,
+      maxContextTokens: parsed.maxContextTokens,
+      maxInputTokens: parsed.maxInputTokens,
+      timeoutMs: parsed.timeoutMs,
+      bypassOptimization: parsed.bypassOptimization
+    });
+    if (parsed.json) {
+      io.stdout.write(`${toPrettyJson(result)}
+`);
+      return 0;
+    }
+    if (parsed.plain) {
+      io.stdout.write(`${result.finalPrompt}
+`);
+      return 0;
+    }
+    io.stdout.write(`${result.finalPrompt}
+
+`);
+    io.stdout.write(`provider=${result.provider} model=${result.model} tokens=${result.estimatedTokensAfter.total} savings=${result.tokenSavings}
+`);
+    if (result.warnings.length > 0) {
+      io.stdout.write(`warnings=${result.warnings.join(" | ")}
+`);
+    }
+    return 0;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown CLI error.";
+    io.stderr.write(`${message}
+`);
+    return 1;
+  }
+}
+function parseOptimizeArgs(args) {
+  const parsed = {
+    plain: false,
+    json: false,
+    debug: false,
+    clearSession: false,
+    useContext: true,
+    bypassOptimization: false,
+    help: false,
+    tags: [],
+    pinnedConstraints: []
+  };
+  const positionals = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    switch (arg) {
+      case "--session":
+        parsed.sessionId = args[++index];
+        break;
+      case "--model":
+        parsed.model = args[++index];
+        break;
+      case "--mode":
+        parsed.mode = args[++index];
+        break;
+      case "--task":
+        parsed.task = args[++index];
+        break;
+      case "--tone":
+        parsed.tone = args[++index];
+        break;
+      case "--preset":
+        parsed.preset = args[++index];
+        break;
+      case "--target-model":
+        parsed.targetModel = args[++index];
+        break;
+      case "--output-format":
+        parsed.outputFormat = args[++index];
+        break;
+      case "--max-length":
+        parsed.maxLength = Number(args[++index]);
+        break;
+      case "--tag":
+        parsed.tags.push(args[++index]);
+        break;
+      case "--pin-constraint":
+        parsed.pinnedConstraints.push(args[++index]);
+        break;
+      case "--host":
+        parsed.host = args[++index];
+        break;
+      case "--store":
+        parsed.contextStore = args[++index];
+        break;
+      case "--storage-dir":
+        parsed.storageDir = args[++index];
+        break;
+      case "--sqlite-path":
+        parsed.sqlitePath = args[++index];
+        break;
+      case "--plain":
+        parsed.plain = true;
+        break;
+      case "--json":
+        parsed.json = true;
+        break;
+      case "--debug":
+        parsed.debug = true;
+        break;
+      case "--save-context":
+        parsed.saveContext = true;
+        break;
+      case "--no-context":
+        parsed.useContext = false;
+        break;
+      case "--clear-session":
+        parsed.clearSession = true;
+        break;
+      case "--max-total-tokens":
+        parsed.maxTotalTokens = Number(args[++index]);
+        break;
+      case "--max-context-tokens":
+        parsed.maxContextTokens = Number(args[++index]);
+        break;
+      case "--max-input-tokens":
+        parsed.maxInputTokens = Number(args[++index]);
+        break;
+      case "--timeout":
+        parsed.timeoutMs = Number(args[++index]);
+        break;
+      case "--bypass-optimization":
+        parsed.bypassOptimization = true;
+        break;
+      case "--help":
+      case "-h":
+        parsed.help = true;
+        break;
+      default:
+        positionals.push(arg);
+    }
+  }
+  parsed.prompt = positionals.join(" ").trim() || void 0;
+  return parsed;
+}
+function getHelpText() {
+  return [
+    "promptpilot optimize <prompt> [options]",
+    "",
+    "Options:",
+    "  --session <id>",
+    "  --model <name>           Override auto-selected local Ollama model",
+    "  --mode <mode>",
+    "  --task <task>",
+    "  --tone <tone>",
+    "  --preset <preset>",
+    "  --target-model <name>",
+    "  --output-format <text>",
+    "  --max-length <n>",
+    "  --tag <value>             Repeatable",
+    "  --pin-constraint <text>   Repeatable",
+    "  --host <url>",
+    "  --store <local|sqlite>",
+    "  --storage-dir <path>",
+    "  --sqlite-path <path>",
+    "  --plain",
+    "  --json",
+    "  --debug",
+    "  --save-context",
+    "  --no-context",
+    "  --clear-session",
+    "  --max-total-tokens <n>",
+    "  --max-context-tokens <n>",
+    "  --max-input-tokens <n>",
+    "  --timeout <ms>",
+    "  --bypass-optimization"
+  ].join("\n");
+}
+async function readStdin(stdin = process.stdin) {
+  if (!stdin || stdin.isTTY) {
+    return "";
+  }
+  return new Promise((resolve, reject) => {
+    let data = "";
+    stdin.setEncoding("utf8");
+    stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    stdin.on("end", () => resolve(data));
+    stdin.on("error", reject);
+  });
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  runCli(process.argv.slice(2)).then((code) => {
+    process.exit(code);
+  });
+}
+export {
+  runCli
+};
+//# sourceMappingURL=cli.js.map