@wrongstack/core 0.1.9 → 0.2.0

package/dist/models/index.d.ts

@@ -0,0 +1,60 @@
+export { D as DefaultModelsRegistry, a as DefaultModelsRegistryOptions, c as classifyFamily } from '../models-registry-DqzwpBQy.js';
+import { c as ModeStore, a as ModeConfig, M as Mode } from '../mode-CV077NjV.js';
+import { g as Provider, M as Message } from '../context-u0bryklF.js';
+import { M as MessageSelector, S as SelectorResult } from '../selector-BRqzvugb.js';
+import '../models-registry-Y2xbog0E.js';
+
+declare class DefaultModeStore implements ModeStore {
+    private activeModeId;
+    private modes;
+    private configDir;
+    constructor(config: ModeConfig);
+    getActiveMode(): Promise<Mode | null>;
+    setActiveMode(modeId: string | null): Promise<void>;
+    listModes(): Promise<Mode[]>;
+    getMode(modeId: string): Promise<Mode | null>;
+    addMode(mode: Mode): Promise<void>;
+    removeMode(modeId: string): Promise<void>;
+    private loadActiveMode;
+    private saveActiveMode;
+}
+interface ModeLoaderOptions {
+    projectModesDir?: string;
+    userModesDir?: string;
+}
+declare function loadProjectModes(modesDir: string): Promise<Mode[]>;
+declare function loadUserModes(modesDir: string): Promise<Mode[]>;
+
+interface LLMSelectorOptions {
+    /** Provider used for the selector LLM call. Required. */
+    provider: Provider;
+    /** Model for the selector. Defaults to the provider's default model. */
+    model?: string;
+    /**
+     * Maximum tokens to keep in context (target budget).
+     * Selector will aim to keep total content below this.
+     */
+    maxContextTokens?: number;
+    /**
+     * Prompt instructing the selector how to behave.
+     * Should guide the LLM on importance tiers and output format.
+     */
+    systemPrompt?: string;
+}
+/**
+ * LLM-powered message selector. Calls a sub-LLM to analyze the
+ * message history and produce a keep/collapse plan — more surgical
+ * than fixed-window rules.
+ */
+declare class LLMSelector implements MessageSelector {
+    private readonly provider;
+    private readonly model;
+    private readonly maxContextTokens;
+    private readonly systemPrompt;
+    constructor(opts: LLMSelectorOptions);
+    select(messages: Message[], maxToKeep: number): Promise<SelectorResult>;
+    private fallbackSelect;
+    private parseSelectorOutput;
+}
+
+export { DefaultModeStore, LLMSelector, type LLMSelectorOptions, type ModeLoaderOptions, loadProjectModes, loadUserModes };

package/dist/models/index.js

@@ -0,0 +1,621 @@
+import * as fs from 'fs/promises';
+import * as path3 from 'path';
+import { randomBytes } from 'crypto';
+
+// src/models/models-registry.ts
+async function atomicWrite(targetPath, content, opts = {}) {
+  const dir = path3.dirname(targetPath);
+  await fs.mkdir(dir, { recursive: true });
+  const tmp = path3.join(dir, `.${path3.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
+  try {
+    if (typeof content === "string") {
+      await fs.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
+    } else {
+      await fs.writeFile(tmp, content, { flag: "wx" });
+    }
+    try {
+      const fh = await fs.open(tmp, "r+");
+      try {
+        await fh.sync();
+      } finally {
+        await fh.close();
+      }
+    } catch {
+    }
+    let mode;
+    try {
+      const stat3 = await fs.stat(targetPath);
+      mode = stat3.mode & 511;
+    } catch {
+      mode = opts.mode;
+    }
+    if (mode !== void 0) {
+      await fs.chmod(tmp, mode);
+    }
+    await fs.rename(tmp, targetPath);
+  } catch (err) {
+    try {
+      await fs.unlink(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+
+// src/models/models-registry.ts
+var DEFAULT_URL = "https://models.dev/api.json";
+var DEFAULT_TTL_SECONDS = 24 * 3600;
+var FAMILY_BY_NPM = {
+  "@ai-sdk/anthropic": "anthropic",
+  "@ai-sdk/google-vertex/anthropic": "anthropic",
+  "@ai-sdk/openai": "openai",
+  "@ai-sdk/openai-compatible": "openai-compatible",
+  "@ai-sdk/groq": "openai-compatible",
+  "@ai-sdk/xai": "openai-compatible",
+  "@ai-sdk/cerebras": "openai-compatible",
+  "@ai-sdk/togetherai": "openai-compatible",
+  "@ai-sdk/perplexity": "openai-compatible",
+  "@ai-sdk/deepinfra": "openai-compatible",
+  "@openrouter/ai-sdk-provider": "openai-compatible",
+  "ai-gateway-provider": "openai-compatible",
+  "@ai-sdk/vercel": "openai-compatible",
+  "@ai-sdk/gateway": "openai-compatible",
+  "@aihubmix/ai-sdk-provider": "openai-compatible",
+  "venice-ai-sdk-provider": "openai-compatible",
+  "@ai-sdk/google": "google"
+};
+function classifyFamily(npm) {
+  if (!npm) return "unsupported";
+  return FAMILY_BY_NPM[npm] ?? "unsupported";
+}
+var DefaultModelsRegistry = class {
+  payload;
+  fetchedAt;
+  cacheFile;
+  url;
+  ttlMs;
+  fetchImpl;
+  seed;
+  maxStaleAgeMs;
+  constructor(opts) {
+    this.cacheFile = opts.cacheFile;
+    this.url = opts.url ?? DEFAULT_URL;
+    this.ttlMs = (opts.ttlSeconds ?? DEFAULT_TTL_SECONDS) * 1e3;
+    this.fetchImpl = opts.fetchImpl ?? fetch;
+    this.seed = opts.seed;
+    const maxStaleSeconds = opts.maxStaleAgeSeconds ?? 7 * 24 * 3600;
+    this.maxStaleAgeMs = maxStaleSeconds * 1e3;
+  }
+  async load(opts = {}) {
+    if (this.payload && !opts.force) return this.payload;
+    if (this.seed) {
+      this.payload = this.seed;
+      this.fetchedAt = /* @__PURE__ */ new Date();
+      return this.payload;
+    }
+    if (!opts.force) {
+      const cached = await this.readCache();
+      if (cached && this.isFresh(cached.fetchedAt)) {
+        this.payload = cached.payload;
+        this.fetchedAt = new Date(cached.fetchedAt);
+        return cached.payload;
+      }
+    }
+    try {
+      return await this.refresh();
+    } catch (err) {
+      const cached = await this.readCache();
+      if (cached && this.isWithinMaxStaleAge(cached.fetchedAt)) {
+        this.payload = cached.payload;
+        this.fetchedAt = new Date(cached.fetchedAt);
+        return cached.payload;
+      }
+      throw err;
+    }
+  }
+  async refresh() {
+    const res = await this.fetchImpl(this.url, {
+      method: "GET",
+      headers: { accept: "application/json" }
+    });
+    if (!res.ok) {
+      throw new Error(`ModelsRegistry: HTTP ${res.status} fetching ${this.url}`);
+    }
+    const json = await res.json();
+    this.payload = json;
+    this.fetchedAt = /* @__PURE__ */ new Date();
+    const envelope = {
+      fetchedAt: this.fetchedAt.toISOString(),
+      url: this.url,
+      payload: json
+    };
+    await atomicWrite(this.cacheFile, JSON.stringify(envelope));
+    return json;
+  }
+  async listProviders() {
+    const payload = await this.load();
+    return Object.values(payload).map((p) => this.resolveProvider(p));
+  }
+  async getProvider(id) {
+    const payload = await this.load();
+    const p = payload[id];
+    return p ? this.resolveProvider(p) : void 0;
+  }
+  async getModel(providerId, modelId) {
+    const provider = await this.getProvider(providerId);
+    if (!provider) return void 0;
+    const model = provider.models.find((m) => m.id === modelId);
+    if (!model) return void 0;
+    return {
+      providerId,
+      modelId,
+      capabilities: {
+        tools: model.tool_call ?? false,
+        vision: Boolean(model.modalities?.input?.includes("image")),
+        reasoning: model.reasoning ?? false,
+        maxContext: model.limit?.context ?? 0,
+        maxOutput: model.limit?.output,
+        knowledge: model.knowledge
+      },
+      cost: model.cost
+    };
+  }
+  async suggestModel(providerId) {
+    const provider = await this.getProvider(providerId);
+    if (!provider || provider.models.length === 0) return void 0;
+    const ranked = [...provider.models].sort((a, b) => {
+      const at = a.release_date ?? a.last_updated ?? "";
+      const bt = b.release_date ?? b.last_updated ?? "";
+      return bt.localeCompare(at);
+    });
+    return ranked[0]?.id;
+  }
+  async ageSeconds() {
+    if (!this.fetchedAt) {
+      const cached = await this.readCache();
+      if (!cached) return Number.POSITIVE_INFINITY;
+      return (Date.now() - new Date(cached.fetchedAt).getTime()) / 1e3;
+    }
+    return (Date.now() - this.fetchedAt.getTime()) / 1e3;
+  }
+  resolveProvider(p) {
+    return {
+      id: p.id,
+      name: p.name,
+      family: classifyFamily(p.npm),
+      apiBase: p.api,
+      envVars: p.env ?? [],
+      doc: p.doc,
+      models: Object.values(p.models ?? {}),
+      npm: p.npm
+    };
+  }
+  isFresh(fetchedAtIso) {
+    return Date.now() - new Date(fetchedAtIso).getTime() < this.ttlMs;
+  }
+  isWithinMaxStaleAge(fetchedAtIso) {
+    return Date.now() - new Date(fetchedAtIso).getTime() < this.maxStaleAgeMs;
+  }
+  async readCache() {
+    try {
+      const raw = await fs.readFile(this.cacheFile, "utf8");
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  /** Used by `wstack models refresh` to expose where the cache lives. */
+  cacheLocation() {
+    return path3.resolve(this.cacheFile);
+  }
+};
+
+// src/types/mode.ts
+var DEFAULT_MODES = [
+  {
+    id: "default",
+    name: "Default",
+    description: "General-purpose coding assistant",
+    prompt: "",
+    tags: ["general"]
+  },
+  {
+    id: "code-reviewer",
+    name: "Code Reviewer",
+    description: "Focus on code quality, best practices, and potential bugs",
+    prompt: `## Code Reviewer Mode
+
+When reviewing code:
+- Look for potential bugs, race conditions, and edge cases
+- Check for security vulnerabilities (SQL injection, XSS, CSRF, etc.)
+- Evaluate error handling completeness
+- Assess code readability and maintainability
+- Check for performance anti-patterns
+- Verify test coverage for critical paths
+- Ensure naming conventions are followed`,
+    tags: ["review", "quality", "security"],
+    toolPreferences: ["read", "grep", "git", "diff", "test"]
+  },
+  {
+    id: "code-auditor",
+    name: "Code Auditor",
+    description: "Security-focused code analysis",
+    prompt: `## Code Auditor Mode
+
+When auditing code for security:
+- Identify injection vulnerabilities (SQL, Command, XSS, LDAP)
+- Check authentication and authorization patterns
+- Look for sensitive data exposure (secrets, PII in logs)
+- Verify cryptographic implementations
+- Check for insecure dependencies or configurations
+- Assess input validation and output encoding
+- Look for timing attacks and information leakage`,
+    tags: ["security", "audit", "compliance"],
+    toolPreferences: ["grep", "read", "audit", "bash"]
+  },
+  {
+    id: "architect",
+    name: "Software Architect",
+    description: "Design patterns, scalability, and system design",
+    prompt: `## Architect Mode
+
+When designing or reviewing architecture:
+- Evaluate scalability and future growth
+- Check for appropriate design patterns
+- Assess coupling and cohesion
+- Look forSOLID principle violations
+- Evaluate data modeling decisions
+- Check for eventual consistency issues
+- Assess API design and contract stability
+- Consider operational aspects (monitoring, logging, deployment)`,
+    tags: ["architecture", "design", "scalability"],
+    toolPreferences: ["read", "glob", "tree", "diff"]
+  },
+  {
+    id: "debugger",
+    name: "Debugger",
+    description: "Root cause analysis and error investigation",
+    prompt: `## Debugger Mode
+
+When investigating bugs:
+- Reproduce the issue with minimal steps
+- Check error messages and stack traces thoroughly
+- Look for related logs and historical context
+- Verify assumptions about data flow
+- Check for race conditions in async code
+- Validate environment and configuration
+- Use binary search to isolate the root cause
+- Verify fixes with tests before considering done`,
+    tags: ["debug", "investigation", "error-resolution"],
+    toolPreferences: ["read", "grep", "bash", "logs", "test"]
+  },
+  {
+    id: "tester",
+    name: "QA Engineer",
+    description: "Test coverage, edge cases, and quality assurance",
+    prompt: `## Tester Mode
+
+When testing or writing tests:
+- Cover happy path and error paths equally
+- Think about edge cases and boundary conditions
+- Check for missing null/undefined handling tests
+- Verify error messages are tested
+- Look for race condition tests in async code
+- Assess mutation testing opportunities
+- Check for integration test gaps
+- Verify test isolation and cleanup`,
+    tags: ["testing", "qa", "quality"],
+    toolPreferences: ["read", "grep", "test", "bash"]
+  },
+  {
+    id: "devops",
+    name: "DevOps Engineer",
+    description: "Infrastructure, deployment, and operations",
+    prompt: `## DevOps Mode
+
+When working on infrastructure:
+- Check for containerization and deployment readiness
+- Verify CI/CD pipeline configurations
+- Assess monitoring and alerting setup
+- Look for health check endpoints
+- Check for graceful shutdown handling
+- Verify backup and disaster recovery plans
+- Assess secrets management
+- Check for resource limits and quotas`,
+    tags: ["devops", "infrastructure", "operations"],
+    toolPreferences: ["read", "bash", "grep", "logs", "git"]
+  },
+  {
+    id: "refactorer",
+    name: "Refactorer",
+    description: "Code improvement and modernization",
+    prompt: `## Refactorer Mode
+
+When refactoring code:
+- Maintain existing behavior \u2014 tests must pass before and after
+- Make one change at a time, verify after each
+- Prefer small, focused commits
+- Preserve API contracts unless explicitly changing
+- Remove dead code and comments
+- Improve naming as you go
+- Don't mix formatting changes with logic changes
+- Keep performance in mind \u2014 don't regress`,
+    tags: ["refactor", "modernization", "improvement"],
+    toolPreferences: ["read", "edit", "test", "git", "grep"]
+  }
+];
+
+// src/models/mode-store.ts
+var DefaultModeStore = class {
+  activeModeId = null;
+  modes;
+  configDir;
+  constructor(config) {
+    this.configDir = config.directory;
+    this.modes = [...DEFAULT_MODES];
+  }
+  async getActiveMode() {
+    if (!this.activeModeId) {
+      await this.loadActiveMode();
+    }
+    if (!this.activeModeId) return null;
+    return this.modes.find((m) => m.id === this.activeModeId) ?? null;
+  }
+  async setActiveMode(modeId) {
+    this.activeModeId = modeId;
+    await this.saveActiveMode();
+  }
+  async listModes() {
+    return [...this.modes];
+  }
+  async getMode(modeId) {
+    return this.modes.find((m) => m.id === modeId) ?? null;
+  }
+  async addMode(mode) {
+    const idx = this.modes.findIndex((m) => m.id === mode.id);
+    if (idx >= 0) {
+      this.modes[idx] = mode;
+    } else {
+      this.modes.push(mode);
+    }
+  }
+  async removeMode(modeId) {
+    const builtIn = DEFAULT_MODES.find((m) => m.id === modeId);
+    if (builtIn) {
+      throw new Error(`Cannot remove built-in mode "${modeId}"`);
+    }
+    this.modes = this.modes.filter((m) => m.id !== modeId);
+    if (this.activeModeId === modeId) {
+      this.activeModeId = null;
+      await this.saveActiveMode();
+    }
+  }
+  async loadActiveMode() {
+    try {
+      const configPath = path3.join(this.configDir, "mode.json");
+      const content = await fs.readFile(configPath, "utf8");
+      const data = JSON.parse(content);
+      this.activeModeId = data.activeMode ?? null;
+    } catch {
+      this.activeModeId = "default";
+    }
+  }
+  async saveActiveMode() {
+    try {
+      await fs.mkdir(this.configDir, { recursive: true });
+      const configPath = path3.join(this.configDir, "mode.json");
+      await fs.writeFile(
+        configPath,
+        JSON.stringify({ activeMode: this.activeModeId }, null, 2),
+        "utf8"
+      );
+    } catch {
+    }
+  }
+};
+async function loadProjectModes(modesDir) {
+  const modes = [];
+  try {
+    const entries = await fs.readdir(modesDir);
+    for (const entry of entries) {
+      if (!entry.endsWith(".md") && !entry.endsWith(".txt")) continue;
+      const filePath = path3.join(modesDir, entry);
+      const stat3 = await fs.stat(filePath);
+      if (!stat3.isFile()) continue;
+      const content = await fs.readFile(filePath, "utf8");
+      const id = path3.basename(entry, path3.extname(entry));
+      modes.push({
+        id,
+        name: id.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
+        description: content.split("\n")[0] ?? id,
+        prompt: content,
+        tags: ["project"]
+      });
+    }
+  } catch {
+  }
+  return modes;
+}
+async function loadUserModes(modesDir) {
+  const modes = [];
+  try {
+    const manifestPath = path3.join(modesDir, "modes.json");
+    const content = await fs.readFile(manifestPath, "utf8");
+    const manifest = JSON.parse(content);
+    for (const mode of manifest.modes) {
+      modes.push(mode);
+    }
+  } catch {
+  }
+  return modes;
+}
+
+// src/types/blocks.ts
+function isTextBlock(b) {
+  return b.type === "text";
+}
+
+// src/models/llm-selector.ts
+var DEFAULT_SYSTEM_PROMPT = `You are a context pruning assistant. Given a conversation history and a token budget, decide which message ranges are worth keeping verbatim and which should be collapsed into summaries.
+
+Output a JSON object with this structure:
+{
+  "kept": [{"from": 0, "to": 5, "importance": "critical"}],
+  "collapsed": [{"from": 6, "to": 20, "summary": "optional summary"}],
+  "reasoning": "brief explanation of decisions"
+}
+
+Importance tiers:
+- "critical": decisions, file edits, tool results that affect state, final answers
+- "high": substantive tool use, complex reasoning, non-obvious observations
+- "medium": routine exchanges, confirmations, straightforward Q&A
+
+Rules:
+- Always keep the most recent K pairs (preserve recency)
+- Never collapse the final 2 user/assistant pairs (working memory)
+- Preserve tool results that modified files or had external effects
+- Collapse old, low-information exchanges (greetings, acknowledgements, etc.)
+- If unsure, keep rather than collapse (errors are more costly than waste)
+
+Return ONLY the JSON object, no markdown, no explanation outside the JSON.`;
+function estimateTokens(messages) {
+  let total = 0;
+  for (const m of messages) {
+    if (typeof m.content === "string") {
+      total += Math.ceil(m.content.length / 4);
+    } else if (Array.isArray(m.content)) {
+      for (const b of m.content) {
+        if (b.type === "text") total += Math.ceil(b.text.length / 4);
+        else total += Math.ceil(JSON.stringify(b).length / 4);
+      }
+    }
+  }
+  return total;
+}
+function formatMessages(messages, maxChars = 8e3) {
+  const lines = [];
+  let used = 0;
+  for (let i = 0; i < messages.length; i++) {
+    const m = messages[i];
+    const role = m.role.padEnd(10, " ");
+    let text;
+    if (typeof m.content === "string") {
+      text = m.content.slice(0, 500);
+    } else {
+      const content = m.content;
+      text = content.filter(isTextBlock).map((b) => b.text).join(" ");
+      const toolUses = content.filter((b) => b.type === "tool_use");
+      if (toolUses.length > 0) {
+        text += ` [tools: ${toolUses.map((b) => b.name).join(", ")}]`;
+      }
+    }
+    const line = `[${i}][${role}]: ${text}`;
+    if (used + line.length > maxChars) break;
+    lines.push(line);
+    used += line.length;
+  }
+  return lines.join("\n");
+}
+var LLMSelector = class {
+  provider;
+  model;
+  maxContextTokens;
+  systemPrompt;
+  constructor(opts) {
+    this.provider = opts.provider;
+    this.model = opts.model ?? "unknown";
+    this.maxContextTokens = opts.maxContextTokens ?? 4e4;
+    this.systemPrompt = opts.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+  }
+  async select(messages, maxToKeep) {
+    const effectiveBudget = Math.min(maxToKeep, this.maxContextTokens);
+    const historyText = formatMessages(messages);
+    const totalTokens = estimateTokens(messages);
+    const systemText = `${this.systemPrompt}
+
+Conversation (${messages.length} messages, ~${totalTokens} tokens, budget: ${effectiveBudget}):
+`;
+    const budgetInstruction = totalTokens > effectiveBudget ? `
+
+IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiveBudget}). You MUST collapse enough to fit. Prefer collapsing older/lower-importance ranges.` : "";
+    const req = {
+      model: this.model,
+      system: [{ type: "text", text: systemText + budgetInstruction }],
+      messages: [{ role: "user", content: historyText }],
+      maxTokens: 1024
+    };
+    let raw;
+    try {
+      const ac = new AbortController();
+      const res = await this.provider.complete(req, { signal: ac.signal });
+      const textBlocks = res.content.filter(isTextBlock);
+      raw = textBlocks.map((b) => b.text).join("\n").trim();
+    } catch (err) {
+      return this.fallbackSelect(messages, effectiveBudget);
+    }
+    return this.parseSelectorOutput(raw, messages.length);
+  }
+  fallbackSelect(messages, budget) {
+    const toKeep = [];
+    const toCollapse = [];
+    let tokenCount = 0;
+    let startIdx = 0;
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const m = messages[i];
+      const cost = typeof m.content === "string" ? Math.ceil(m.content.length / 4) : m.content.reduce(
+        (acc, b) => acc + (b.type === "text" ? Math.ceil(b.text.length / 4) : Math.ceil(JSON.stringify(b).length / 4)),
+        0
+      );
+      if (tokenCount + cost <= budget) {
+        tokenCount += cost;
+      } else {
+        startIdx = i + 1;
+        break;
+      }
+    }
+    if (startIdx > 0) {
+      toCollapse.push({ from: 0, to: startIdx - 1 });
+    }
+    toKeep.push({ from: startIdx, to: messages.length - 1, importance: "high" });
+    return {
+      kept: toKeep,
+      collapsed: toCollapse,
+      reasoning: `Fallback: kept last ${messages.length - startIdx} messages within ${budget} token budget`
+    };
+  }
+  parseSelectorOutput(raw, messageCount) {
+    const jsonStart = raw.indexOf("{");
+    const jsonEnd = raw.lastIndexOf("}");
+    if (jsonStart === -1 || jsonEnd === -1) {
+      return this.fallbackSelect(
+        Array.from({ length: messageCount }, () => ({ role: "user", content: "" })),
+        this.maxContextTokens
+      );
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw.slice(jsonStart, jsonEnd + 1));
+    } catch {
+      return this.fallbackSelect(
+        Array.from({ length: messageCount }, () => ({ role: "user", content: "" })),
+        this.maxContextTokens
+      );
+    }
+    const obj = parsed;
+    const kept = obj.kept ?? [];
+    const collapsed = obj.collapsed ?? [];
+    return {
+      kept: kept.map((k) => ({
+        from: k.from,
+        to: k.to,
+        importance: k.importance ?? "medium"
+      })),
+      collapsed: collapsed.map((c) => ({ from: c.from, to: c.to, summary: c.summary })),
+      reasoning: typeof obj.reasoning === "string" ? obj.reasoning : ""
+    };
+  }
+};
+
+export { DefaultModeStore, DefaultModelsRegistry, LLMSelector, classifyFamily, loadProjectModes, loadUserModes };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map