@wrongstack/core 0.313.0 → 0.316.1

package/dist/chunk-2FK4WTFF.js

@@ -0,0 +1,207 @@
+// src/types/mode-prompts.ts
+import { readFileSync, statSync } from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+function modePrompt(id) {
+  for (const dir of modePromptDirCandidates()) {
+    try {
+      return readFileSync(path.join(dir, `${id}.md`), "utf8").trimEnd();
+    } catch {
+    }
+  }
+  return "";
+}
+function modePromptDirCandidates() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path.resolve(here, "../../instructions/modes"),
+    path.resolve(here, "../instructions/modes"),
+    path.resolve(here, "instructions/modes")
+  ];
+  return candidates.sort((a, b) => Number(!isDirectory(a)) - Number(!isDirectory(b)));
+}
+function isDirectory(candidate) {
+  try {
+    return statSync(candidate).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// src/types/mode.ts
+var DEFAULT_MODES = [
+  {
+    id: "default",
+    name: "Default",
+    description: "Balanced general-purpose mode; use when no special token/coverage trade-off is needed",
+    prompt: "",
+    tags: ["general", "balanced"]
+  },
+  {
+    id: "brief",
+    name: "Brief",
+    description: "Ultra-compact responses for low-context, high-speed work",
+    prompt: modePrompt("brief"),
+    tags: ["lite", "fast", "concise", "token-saving"],
+    toolPreferences: ["read", "edit", "bash"],
+    suggestedSkills: []
+  },
+  {
+    id: "review-lite",
+    name: "Review Lite",
+    description: "Token-saving code review: changed files only, top correctness/security risks",
+    prompt: modePrompt("review-lite"),
+    tags: ["lite", "review", "quality", "token-saving"],
+    toolPreferences: ["git", "diff", "read", "grep"],
+    suggestedSkills: ["bug-hunter", "typescript-strict"]
+  },
+  {
+    id: "audit-lite",
+    name: "Audit Lite",
+    description: "Token-saving security triage for a small diff or named file",
+    prompt: modePrompt("audit-lite"),
+    tags: ["lite", "security", "audit", "token-saving"],
+    toolPreferences: ["grep", "read", "git"],
+    suggestedSkills: ["security-scanner"]
+  },
+  {
+    id: "plan-lite",
+    name: "Plan Lite",
+    description: "Token-saving planning: 3-6 actionable steps, minimal design debate",
+    prompt: modePrompt("plan-lite"),
+    tags: ["lite", "planning", "architecture", "token-saving"],
+    toolPreferences: ["tree", "glob", "read", "grep"],
+    suggestedSkills: ["refactor-planner"]
+  },
+  {
+    id: "debug-lite",
+    name: "Debug Lite",
+    description: "Token-saving bug triage: one hypothesis, nearest evidence, narrow check",
+    prompt: modePrompt("debug-lite"),
+    tags: ["lite", "debug", "triage", "token-saving"],
+    toolPreferences: ["read", "grep", "test", "logs"],
+    suggestedSkills: ["bug-hunter"]
+  },
+  {
+    id: "test-lite",
+    name: "Test Lite",
+    description: "Token-saving tests: one focused regression or narrow verification target",
+    prompt: modePrompt("test-lite"),
+    tags: ["lite", "testing", "qa", "token-saving"],
+    toolPreferences: ["test", "read", "grep"],
+    suggestedSkills: ["testing"]
+  },
+  {
+    id: "refactor-lite",
+    name: "Refactor Lite",
+    description: "Token-saving cleanup: small scoped behavior-preserving changes",
+    prompt: modePrompt("refactor-lite"),
+    tags: ["lite", "refactor", "token-saving"],
+    toolPreferences: ["read", "edit", "test"],
+    suggestedSkills: ["typescript-strict"]
+  },
+  {
+    id: "research-lite",
+    name: "Research Lite",
+    description: "Token-saving web research: one search, one authoritative fetch, short answer",
+    prompt: modePrompt("research-lite"),
+    tags: ["lite", "research", "web", "token-saving"],
+    toolPreferences: ["search", "fetch"],
+    suggestedSkills: ["research-web"]
+  },
+  {
+    id: "code-reviewer",
+    name: "Review Deep",
+    description: "Comprehensive code review across contracts, edge cases, lifecycle, errors, concurrency",
+    prompt: modePrompt("code-reviewer"),
+    tags: ["deep", "review", "quality", "security"],
+    toolPreferences: ["read", "grep", "git", "diff", "test"],
+    suggestedSkills: ["bug-hunter", "security-scanner", "typescript-strict", "testing"]
+  },
+  {
+    id: "code-auditor",
+    name: "Audit Deep",
+    description: "Comprehensive security audit with category coverage and exploitability notes",
+    prompt: modePrompt("code-auditor"),
+    tags: ["deep", "security", "audit", "compliance"],
+    toolPreferences: ["grep", "read", "audit", "bash"],
+    suggestedSkills: ["security-scanner", "bug-hunter", "audit-log"]
+  },
+  {
+    id: "architect",
+    name: "Architecture Deep",
+    description: "Comprehensive architecture and cross-module contract analysis",
+    prompt: modePrompt("architect"),
+    tags: ["deep", "architecture", "design", "scalability"],
+    toolPreferences: ["read", "glob", "tree", "diff"],
+    suggestedSkills: ["api-design", "refactor-planner", "node-modern", "docker-deploy"]
+  },
+  {
+    id: "debugger",
+    name: "Debug Deep",
+    description: "Comprehensive root-cause analysis with traces, logs, assumptions, and verification",
+    prompt: modePrompt("debugger"),
+    tags: ["deep", "debug", "investigation", "error-resolution"],
+    toolPreferences: ["read", "grep", "bash", "logs", "test"],
+    suggestedSkills: ["bug-hunter", "audit-log", "observability"]
+  },
+  {
+    id: "tester",
+    name: "Test Deep",
+    description: "Comprehensive QA mode for coverage, boundaries, isolation, and integration gaps",
+    prompt: modePrompt("tester"),
+    tags: ["deep", "testing", "qa", "quality"],
+    toolPreferences: ["read", "grep", "test", "bash"],
+    suggestedSkills: ["testing", "bug-hunter", "typescript-strict"]
+  },
+  {
+    id: "devops",
+    name: "DevOps Deep",
+    description: "Comprehensive infrastructure, deployment, observability, and operations review",
+    prompt: modePrompt("devops"),
+    tags: ["deep", "devops", "infrastructure", "operations"],
+    toolPreferences: ["read", "bash", "grep", "logs", "git"],
+    suggestedSkills: ["docker-deploy", "observability", "security-scanner"]
+  },
+  {
+    id: "refactorer",
+    name: "Refactor Deep",
+    description: "Comprehensive modernization/refactor mode with contracts and verification discipline",
+    prompt: modePrompt("refactorer"),
+    tags: ["deep", "refactor", "modernization", "improvement"],
+    toolPreferences: ["read", "edit", "test", "git", "grep"],
+    suggestedSkills: ["refactor-planner", "typescript-strict", "node-modern", "testing"]
+  },
+  {
+    id: "ui-design",
+    name: "UI Design Deep",
+    description: "Comprehensive design-first frontend/mobile UI work with kit, tokens, and accessibility",
+    prompt: modePrompt("ui-design"),
+    tags: ["deep", "ui", "frontend", "mobile", "design"],
+    toolPreferences: ["design", "write", "edit", "read", "scaffold"],
+    suggestedSkills: ["react-modern"]
+  },
+  {
+    id: "teach",
+    name: "Teach Deep",
+    description: "Mentor mode with explanations, mental models, trade-offs, and takeaways",
+    prompt: modePrompt("teach"),
+    tags: ["deep", "teaching", "mentor", "learning"],
+    toolPreferences: ["read", "edit", "explain"],
+    suggestedSkills: ["prompt-engineering", "skill-creator", "node-modern", "typescript-strict"]
+  },
+  {
+    id: "research-web",
+    name: "Research Deep",
+    description: "Comprehensive current-data research with cross-checking and reusable findings",
+    prompt: modePrompt("research-web"),
+    tags: ["deep", "research", "web", "current-data", "up-to-date"],
+    toolPreferences: ["search", "fetch", "context_manager"],
+    suggestedSkills: ["research-web", "tech-stack", "node-modern", "security-scanner", "react-modern"]
+  }
+];
+
+export {
+  DEFAULT_MODES
+};
+//# sourceMappingURL=chunk-2FK4WTFF.js.map

package/dist/chunk-2YU4WVBW.js

@@ -0,0 +1,134 @@
+// src/chronicle/prompt-manifest.ts
+import { createHash } from "node:crypto";
+function createChroniclePromptManifest(request) {
+  const roleCounts = {}, blockCounts = {};
+  const messages = request.messages.map((message, index) => messageSummary(message, index, roleCounts, blockCounts));
+  const systemText = (request.system ?? []).map((block) => block.text).join("\n");
+  const toolRecords = (request.tools ?? []).map((tool) => ({
+    name: tool.name,
+    schemaHash: hash(stable(tool.inputSchema)),
+    permission: tool.permission,
+    mutating: tool.mutating,
+    riskTier: tool.riskTier,
+    capabilities: tool.capabilities,
+    estimatedTokens: tool._estDefTokens ?? 0
+  }));
+  const core = {
+    systemHash: hash(systemText),
+    messages: messages.map(({ hash: contentHash, ...rest }) => ({ ...rest, contentHash })),
+    tools: toolRecords,
+    model: request.model,
+    maxTokens: request.maxTokens,
+    temperature: request.temperature,
+    topP: request.topP,
+    topK: request.topK,
+    seed: request.seed,
+    toolChoice: request.toolChoice,
+    reasoning: request.reasoning,
+    cache: request.cache,
+    responseFormat: request.responseFormat?.type
+  };
+  return {
+    manifestId: `prompt_${hash(stable(core))}`,
+    messageCount: messages.length,
+    estimatedMessageTokens: messages.reduce((sum, message) => sum + (message.estimatedTokens ?? 0), 0),
+    contentBytes: messages.reduce((sum, message) => sum + message.bytes, 0) + Buffer.byteLength(systemText),
+    roleCounts,
+    blockCounts,
+    system: { blockCount: request.system?.length ?? 0, bytes: Buffer.byteLength(systemText), hash: hash(systemText) },
+    messages,
+    tools: {
+      count: toolRecords.length,
+      estimatedDefinitionTokens: toolRecords.reduce((sum, tool) => sum + tool.estimatedTokens, 0),
+      manifestHash: hash(stable(toolRecords)),
+      names: toolRecords.map((tool) => tool.name),
+      mutating: toolRecords.filter((tool) => tool.mutating).length,
+      destructive: toolRecords.filter((tool) => tool.riskTier === "destructive").length
+    },
+    request: {
+      maxTokens: request.maxTokens,
+      temperature: request.temperature,
+      topP: request.topP,
+      topK: request.topK,
+      frequencyPenalty: request.frequencyPenalty,
+      presencePenalty: request.presencePenalty,
+      seed: request.seed,
+      candidateCount: request.candidateCount,
+      logprobs: request.logprobs,
+      topLogprobs: request.topLogprobs,
+      stopSequenceCount: request.stopSequences?.length ?? 0,
+      toolChoice: request.toolChoice,
+      reasoning: request.reasoning,
+      cache: request.cache,
+      responseFormat: request.responseFormat?.type,
+      safetySettingCount: request.safetySettings?.length ?? 0,
+      userHash: request.user ? hash(request.user) : void 0
+    }
+  };
+}
+function messageSummary(message, index, roles, totals) {
+  roles[message.role] = (roles[message.role] ?? 0) + 1;
+  const blocks = typeof message.content === "string" ? { text: 1 } : countBlocks(message.content);
+  for (const [type, count] of Object.entries(blocks)) totals[type] = (totals[type] ?? 0) + count;
+  const content = contentIdentity(message.content);
+  return {
+    index,
+    role: message.role,
+    bytes: content.bytes,
+    ...message._estTokens !== void 0 ? { estimatedTokens: message._estTokens } : {},
+    hash: content.hash,
+    blocks
+  };
+}
+function countBlocks(blocks) {
+  const counts = {};
+  for (const block of blocks) counts[block.type] = (counts[block.type] ?? 0) + 1;
+  return counts;
+}
+function hash(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function contentIdentity(content) {
+  if (typeof content === "string") return { hash: hash(content), bytes: Buffer.byteLength(content) };
+  const digest = createHash("sha256");
+  let bytes = 0;
+  const add = (value) => {
+    if (!value) return;
+    digest.update(value);
+    bytes += Buffer.byteLength(value);
+  };
+  for (const block of content) {
+    add(block.type);
+    if (block.type === "text") add(block.text);
+    else if (block.type === "thinking") {
+      add(block.thinking);
+      add(block.signature);
+    } else if (block.type === "tool_use") {
+      add(block.id);
+      add(block.name);
+      add(stable(block.input));
+    } else if (block.type === "tool_result") {
+      add(block.tool_use_id);
+      add(block.name);
+      add(block.content);
+      add(String(block.is_error ?? false));
+    } else if (block.type === "image") {
+      add(block.source.type);
+      add(block.source.media_type);
+      add(block.source.url);
+      add(block.source.data);
+    }
+  }
+  return { hash: digest.digest("hex"), bytes };
+}
+function stable(value) {
+  if (value === void 0) return "undefined";
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stable).join(",")}]`;
+  return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, child]) => `${JSON.stringify(key)}:${stable(child)}`).join(",")}}`;
+}
+
+export {
+  createChroniclePromptManifest
+};
+//# sourceMappingURL=chunk-2YU4WVBW.js.map