@wrongstack/core 0.310.1 → 0.313.1

package/dist/chunk-YNCVSFGF.js

@@ -0,0 +1,149 @@
+// src/utils/wstack-paths.ts
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+function canonicalProjectRoot(absRoot) {
+  const checkoutRoot = path.resolve(absRoot);
+  const dotGit = path.join(checkoutRoot, ".git");
+  try {
+    if (!fs.statSync(dotGit).isFile()) return checkoutRoot;
+    const gitDirLine = fs.readFileSync(dotGit, "utf8").trim();
+    const match = /^gitdir:\s*(.+)$/i.exec(gitDirLine);
+    if (!match?.[1]) return checkoutRoot;
+    const gitDir = path.resolve(checkoutRoot, match[1].trim());
+    const commonDirFile = path.join(gitDir, "commondir");
+    if (!fs.statSync(commonDirFile).isFile()) return checkoutRoot;
+    const commonDir = path.resolve(gitDir, fs.readFileSync(commonDirFile, "utf8").trim());
+    const worktreesDir = path.dirname(gitDir);
+    if (path.basename(worktreesDir).toLowerCase() !== "worktrees") return checkoutRoot;
+    if (path.resolve(worktreesDir, "..") !== commonDir) return checkoutRoot;
+    if (path.basename(commonDir).toLowerCase() !== ".git") return checkoutRoot;
+    return path.dirname(commonDir);
+  } catch {
+    return checkoutRoot;
+  }
+}
+function projectHash(absRoot) {
+  return createHash("sha256").update(canonicalProjectRoot(absRoot)).digest("hex").slice(0, 12);
+}
+function projectSlug(absRoot) {
+  const identityRoot = canonicalProjectRoot(absRoot);
+  const base = slugify(path.basename(identityRoot));
+  const hash = createHash("sha256").update(identityRoot).digest("hex").slice(0, 6);
+  return `${base}-${hash}`;
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "project";
+}
+function safeProfileName(name) {
+  const safe = (name ?? "").replace(/[/\\:]/g, "_").replace(/\.\./g, "_").trim();
+  return safe || "default";
+}
+function bootstrapProfileName(globalRoot) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(path.join(globalRoot, "config.json"), "utf8"));
+    return safeProfileName(
+      typeof parsed.activeProfile === "string" ? parsed.activeProfile : void 0
+    );
+  } catch {
+    return "default";
+  }
+}
+function wstackGlobalRoot() {
+  const fromEnv = process.env["WRONGSTACK_HOME"];
+  if (fromEnv && fromEnv.trim().length > 0) return path.resolve(fromEnv);
+  return path.join(os.homedir(), ".wrongstack");
+}
+function resolveWstackPaths(opts) {
+  const globalRoot = opts.globalRoot ?? (opts.userHome ? path.join(opts.userHome, ".wrongstack") : wstackGlobalRoot());
+  const homeDir = opts.userHome ?? os.homedir();
+  const profileName = safeProfileName(opts.profileName ?? bootstrapProfileName(globalRoot));
+  const profileDir = path.join(globalRoot, "profiles", profileName);
+  const hash = projectHash(opts.projectRoot);
+  const slug = projectSlug(opts.projectRoot);
+  const projectDir = path.join(globalRoot, "projects", slug);
+  return {
+    globalRoot,
+    profileName,
+    profileDir,
+    projectRoot: opts.projectRoot,
+    homeDir,
+    configDir: profileDir,
+    globalConfig: path.join(globalRoot, "config.json"),
+    profilesDir: path.join(globalRoot, "profiles"),
+    profileConfig: (name) => {
+      return path.join(globalRoot, "profiles", safeProfileName(name), "config.json");
+    },
+    profileStatuslineConfig: (name) => {
+      return path.join(globalRoot, "profiles", safeProfileName(name), "statusline.json");
+    },
+    profileModeConfig: (name) => {
+      return path.join(globalRoot, "profiles", safeProfileName(name), "mode.json");
+    },
+    profileProviderStatus: (name) => {
+      return path.join(globalRoot, "profiles", safeProfileName(name), "provider-status.json");
+    },
+    profileUpdateCache: (name) => {
+      return path.join(globalRoot, "profiles", safeProfileName(name), "update-cache.json");
+    },
+    secretsKey: path.join(globalRoot, ".key"),
+    globalMemory: path.join(profileDir, "memory.md"),
+    globalSkills: path.join(profileDir, "skills"),
+    globalClaudeSkills: path.join(homeDir, ".claude", "skills"),
+    globalDesignKits: path.join(profileDir, "design-kits"),
+    globalPrompts: path.join(profileDir, "prompts"),
+    globalInstructions: path.join(profileDir, "instructions"),
+    promptUsage: path.join(profileDir, "prompt-usage.json"),
+    cacheDir: path.join(globalRoot, "cache"),
+    modelsCache: path.join(globalRoot, "cache", "models.dev.json"),
+    modelsOverlayCache: path.join(globalRoot, "cache", "models-overlay.json"),
+    historyFile: path.join(profileDir, "history"),
+    logFile: path.join(globalRoot, "logs", "wrongstack.log"),
+    projectDir,
+    projectCodebaseIndex: path.join(projectDir, "codebase-index"),
+    projectMemory: path.join(projectDir, "memory.md"),
+    projectSessions: path.join(projectDir, "sessions"),
+    projectTrust: path.join(projectDir, "trust.json"),
+    projectMeta: path.join(projectDir, "meta.json"),
+    projectLocalConfig: path.join(projectDir, "config.local.json"),
+    inProjectConfig: path.join(opts.projectRoot, ".wrongstack", "config.json"),
+    inProjectAgentsFile: path.join(opts.projectRoot, ".wrongstack", "AGENTS.md"),
+    inProjectSkills: path.join(opts.projectRoot, ".wrongstack", "skills"),
+    inProjectClaudeSkills: path.join(opts.projectRoot, ".claude", "skills"),
+    inProjectPrompts: path.join(opts.projectRoot, ".wrongstack", "prompts"),
+    inProjectInstructions: path.join(opts.projectRoot, ".wrongstack", "instructions"),
+    inProjectDesignKits: path.join(opts.projectRoot, ".wrongstack", "design-kits"),
+    inProjectWorktrees: path.join(opts.projectRoot, ".wrongstack", "worktrees"),
+    projectHash: hash,
+    projectSlug: slug,
+    projectGoal: path.join(projectDir, "goal.json"),
+    projectInputHistory: path.join(projectDir, "input-history.json"),
+    projectSpecs: path.join(projectDir, "specs"),
+    projectTaskGraphs: path.join(projectDir, "task-graphs"),
+    projectSddSession: path.join(projectDir, "sdd-session.json"),
+    projectPlan: path.join(projectDir, "plan.json"),
+    projectAutophase: path.join(projectDir, "autophase"),
+    projectSddBoards: path.join(projectDir, "sdd-boards"),
+    projectRequirementIntakes: path.join(projectDir, "requirement-intakes"),
+    syncConfig: path.join(profileDir, "sync.json"),
+    configHistoryDir: path.join(globalRoot, "config-history"),
+    projectStatus: (statusProjectSlug) => {
+      if (!/^[a-z0-9](?:[a-z0-9-]{0,39})-[a-f0-9]{6}$/.test(statusProjectSlug)) {
+        throw new Error(`Invalid project slug: ${statusProjectSlug}`);
+      }
+      return path.join(globalRoot, "projects", statusProjectSlug, "status.json");
+    }
+  };
+}
+
+export {
+  canonicalProjectRoot,
+  projectHash,
+  projectSlug,
+  safeProfileName,
+  bootstrapProfileName,
+  wstackGlobalRoot,
+  resolveWstackPaths
+};
+//# sourceMappingURL=chunk-YNCVSFGF.js.map

package/dist/chunk-YUPMXOGP.js

@@ -0,0 +1,282 @@
+import {
+  DefaultSecretScrubber
+} from "./chunk-3E244UDA.js";
+
+// src/prompts/prompt-journal.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+var defaultScrubber = new DefaultSecretScrubber();
+var PROMPT_JOURNAL_RAW_MARKER = "promptJournal.raw";
+async function ensureGitignore(projectRoot) {
+  const gitignorePath = path.join(projectRoot, ".gitignore");
+  try {
+    let content = "";
+    try {
+      content = await fs.readFile(gitignorePath, "utf8");
+    } catch {
+      content = "";
+    }
+    if (!content.includes(".wrongstack") && !content.includes(".wrongstack/")) {
+      const addition = content.endsWith("\n") || content.length === 0 ? ".wrongstack/\n" : "\n.wrongstack/\n";
+      await fs.writeFile(gitignorePath, content + addition, "utf8");
+    }
+  } catch {
+  }
+}
+function sessionFileId(sessionId) {
+  const leaf = sessionId.split(/[\\/]/u).pop();
+  return leaf && leaf.trim().length > 0 ? leaf : "general";
+}
+async function recordPromptJournalEntry(opts) {
+  const now = /* @__PURE__ */ new Date();
+  const timestamp = now.toISOString();
+  const dateStr = timestamp.slice(0, 10);
+  const monthStr = dateStr.slice(0, 7);
+  const sessionId = opts.sessionId && opts.sessionId.trim() ? opts.sessionId.trim() : "general";
+  const id = `pmt_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+  const content = defaultScrubber.scrub(opts.content ?? "");
+  const rawContent = typeof opts.rawContent === "string" && opts.rawContent.length > 0 ? defaultScrubber.scrub(opts.rawContent) : opts.rawContent;
+  const decisionReason = typeof opts.decisionReason === "string" && opts.decisionReason.length > 0 ? defaultScrubber.scrub(opts.decisionReason) : opts.decisionReason;
+  const lines = content.split("\n");
+  const characterCount = content.length;
+  const lineCount = lines.length;
+  const tokenEstimate = Math.ceil(characterCount / 4);
+  const entry = {
+    id,
+    timestamp,
+    sessionId,
+    projectRoot: opts.projectRoot,
+    role: opts.role ?? (opts.category === "system_prompt" ? "system" : "user"),
+    category: opts.category,
+    content,
+    rawContent,
+    metadata: {
+      model: opts.model,
+      provider: opts.provider,
+      iterationIndex: opts.iterationIndex,
+      tokenEstimate,
+      characterCount,
+      lineCount,
+      activeTools: opts.activeTools,
+      contextFiles: opts.contextFiles,
+      durationMs: opts.durationMs,
+      decisionReason,
+      tags: opts.tags
+    }
+  };
+  const basePromptsDir = path.join(opts.projectRoot, ".wrongstack", "prompts");
+  const dayDir = path.join(basePromptsDir, monthStr, dateStr);
+  try {
+    await fs.mkdir(dayDir, { recursive: true });
+    await ensureGitignore(opts.projectRoot);
+    const sessionJsonlFile = path.join(dayDir, `session-${sessionFileId(sessionId)}.jsonl`);
+    await fs.appendFile(sessionJsonlFile, JSON.stringify(entry) + "\n", "utf8");
+    const sessionMdFile = path.join(dayDir, `session-${sessionFileId(sessionId)}.md`);
+    const mdSection = formatEntryMarkdown(entry);
+    await fs.appendFile(sessionMdFile, mdSection, "utf8");
+    const dailySummaryFile = path.join(dayDir, "daily-summary.md");
+    await updateDailySummary(dailySummaryFile, dateStr, entry);
+    await updateRootCatalog(basePromptsDir, monthStr, dateStr, sessionId, entry);
+  } catch (err) {
+    console.error?.(`Failed to write hierarchical prompt journal: ${err}`);
+  }
+  return entry;
+}
+function formatEntryMarkdown(entry) {
+  const tagList = [
+    `**Category:** \`${entry.category}\``,
+    `**Role:** \`${entry.role}\``,
+    entry.metadata.model ? `**Model:** \`${entry.metadata.model}\`` : null,
+    `**Tokens (est):** ~${entry.metadata.tokenEstimate}`,
+    entry.metadata.iterationIndex !== void 0 ? `**Iteration:** #${entry.metadata.iterationIndex}` : null,
+    `**Session:** \`${entry.sessionId}\``
+  ].filter(Boolean).join(" | ");
+  let md = `
+### \u{1F4DD} [${entry.timestamp}] \`${entry.id}\`
+${tagList}
+
+`;
+  if (entry.metadata.decisionReason) {
+    md += `> **Rationale:** ${entry.metadata.decisionReason}
+
+`;
+  }
+  if (entry.metadata.activeTools && entry.metadata.activeTools.length > 0) {
+    md += `*Active Tools:* \`${entry.metadata.activeTools.join("`, `")}\`
+
+`;
+  }
+  if (entry.rawContent && entry.rawContent !== entry.content) {
+    md += `**Raw Input:**
+\`\`\`text
+${entry.rawContent.trim()}
+\`\`\`
+
+`;
+    md += `**Refined / Injected Prompt:**
+\`\`\`text
+${entry.content.trim()}
+\`\`\`
+
+`;
+  } else {
+    md += `**Prompt Content:**
+\`\`\`text
+${entry.content.trim()}
+\`\`\`
+
+`;
+  }
+  md += `---
+`;
+  return md;
+}
+async function updateDailySummary(summaryFile, dateStr, entry) {
+  try {
+    let content = "";
+    try {
+      content = await fs.readFile(summaryFile, "utf8");
+    } catch {
+      content = `# \u{1F4C5} Daily Prompt Summary \u2014 ${dateStr}
+
+| Time | ID | Session | Category | Model | Tokens | Rationale |
+| :--- | :--- | :--- | :--- | :--- | :--- | :--- |
+`;
+    }
+    const time = entry.timestamp.slice(11, 19);
+    const model = entry.metadata.model ?? "-";
+    const reason = entry.metadata.decisionReason ? entry.metadata.decisionReason.slice(0, 40) : "-";
+    const row = `| ${time} | [\`${entry.id}\`](session-${sessionFileId(entry.sessionId)}.md) | \`${entry.sessionId}\` | \`${entry.category}\` | ${model} | ~${entry.metadata.tokenEstimate} | ${reason} |
+`;
+    await fs.writeFile(summaryFile, content + row, "utf8");
+  } catch {
+  }
+}
+async function updateRootCatalog(baseDir, monthStr, dateStr, sessionId, entry) {
+  const indexJsonFile = path.join(baseDir, "index.json");
+  const indexMdFile = path.join(baseDir, "index.md");
+  let catalog;
+  try {
+    const raw = await fs.readFile(indexJsonFile, "utf8");
+    catalog = JSON.parse(raw);
+  } catch {
+    catalog = {
+      updatedAt: entry.timestamp,
+      totalPrompts: 0,
+      totalTokensEstimated: 0,
+      months: {}
+    };
+  }
+  catalog.updatedAt = entry.timestamp;
+  catalog.totalPrompts += 1;
+  catalog.totalTokensEstimated += entry.metadata.tokenEstimate;
+  if (!catalog.months[monthStr]) {
+    catalog.months[monthStr] = { days: {} };
+  }
+  const monthData = catalog.months[monthStr];
+  if (!monthData.days[dateStr]) {
+    monthData.days[dateStr] = { sessions: {} };
+  }
+  const dayData = monthData.days[dateStr];
+  if (!dayData.sessions[sessionId]) {
+    dayData.sessions[sessionId] = {
+      promptCount: 0,
+      tokenEstimate: 0,
+      lastTimestamp: entry.timestamp,
+      categories: {}
+    };
+  }
+  const sessionData = dayData.sessions[sessionId];
+  sessionData.promptCount += 1;
+  sessionData.tokenEstimate += entry.metadata.tokenEstimate;
+  sessionData.lastTimestamp = entry.timestamp;
+  sessionData.categories[entry.category] = (sessionData.categories[entry.category] ?? 0) + 1;
+  try {
+    await fs.writeFile(indexJsonFile, JSON.stringify(catalog, null, 2), "utf8");
+    let md = `# \u{1F5C2}\uFE0F Prompt Journal Navigation Index
+
+`;
+    md += `* **Total Prompts Logged:** ${catalog.totalPrompts}
+`;
+    md += `* **Total Tokens (est):** ~${catalog.totalTokensEstimated.toLocaleString()}
+`;
+    md += `* **Last Recorded Activity:** ${catalog.updatedAt}
+
+`;
+    md += `## \u{1F4C5} Recorded Dates & Sessions
+
+`;
+    md += `| Date | Session | Prompts | Tokens (est) | Daily Log | Session Log |
+`;
+    md += `| :--- | :--- | :--- | :--- | :--- | :--- |
+`;
+    for (const [m, mObj] of Object.entries(catalog.months).sort().reverse()) {
+      for (const [d, dObj] of Object.entries(mObj.days).sort().reverse()) {
+        for (const [sId, sData] of Object.entries(dObj.sessions)) {
+          const dailyLink = `[daily-summary.md](./${m}/${d}/daily-summary.md)`;
+          const sessionLink = `[session-${sessionFileId(sId)}.md](./${m}/${d}/session-${sessionFileId(sId)}.md)`;
+          md += `| **${d}** | \`${sId}\` | ${sData.promptCount} | ~${sData.tokenEstimate.toLocaleString()} | ${dailyLink} | ${sessionLink} |
+`;
+        }
+      }
+    }
+    await fs.writeFile(indexMdFile, md, "utf8");
+  } catch {
+  }
+}
+async function getPromptJournalEntries(projectRoot, filter = {}) {
+  const basePromptsDir = path.join(projectRoot, ".wrongstack", "prompts");
+  const results = [];
+  try {
+    const months = await fs.readdir(basePromptsDir);
+    for (const month of months) {
+      if (!/^\d{4}-\d{2}$/.test(month)) continue;
+      if (filter.month && filter.month !== month) continue;
+      const monthDir = path.join(basePromptsDir, month);
+      const days = await fs.readdir(monthDir);
+      for (const day of days) {
+        if (!/^\d{4}-\d{2}-\d{2}$/.test(day)) continue;
+        if (filter.date && filter.date !== day) continue;
+        const dayDir = path.join(monthDir, day);
+        const files = await fs.readdir(dayDir);
+        const jsonlFiles = files.filter((f) => f.startsWith("session-") && f.endsWith(".jsonl"));
+        for (const jsonlFile of jsonlFiles) {
+          const sessionMatch = jsonlFile.match(/^session-(.+)\.jsonl$/);
+          const sId = sessionMatch ? sessionMatch[1] : void 0;
+          if (filter.sessionId && sId !== sessionFileId(filter.sessionId)) continue;
+          const filePath = path.join(dayDir, jsonlFile);
+          const content = await fs.readFile(filePath, "utf8");
+          const lines = content.split("\n");
+          for (const line of lines) {
+            if (!line.trim()) continue;
+            try {
+              const entry = JSON.parse(line);
+              if (filter.sessionId && sessionFileId(entry.sessionId) !== sessionFileId(filter.sessionId)) {
+                continue;
+              }
+              if (filter.category && entry.category !== filter.category) continue;
+              if (filter.since && entry.timestamp < filter.since) continue;
+              results.push(entry);
+            } catch {
+            }
+          }
+        }
+      }
+    }
+  } catch {
+    return [];
+  }
+  results.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+  if (filter.limit && results.length > filter.limit) {
+    return results.slice(-filter.limit);
+  }
+  return results;
+}
+
+export {
+  PROMPT_JOURNAL_RAW_MARKER,
+  ensureGitignore,
+  recordPromptJournalEntry,
+  getPromptJournalEntries
+};
+//# sourceMappingURL=chunk-YUPMXOGP.js.map

package/dist/chunk-YY6APYUM.js

@@ -0,0 +1,49 @@
+// src/security/config-secrets.ts
+function decryptConfigSecrets(cfg, vault, opts) {
+  const warn = opts?.warn ?? ((msg) => console.warn(msg));
+  return walk(cfg, vault, (v, key) => {
+    try {
+      return vault.decrypt(v);
+    } catch (err) {
+      warn(
+        `[secret-vault] Failed to decrypt "${key}": ${err instanceof Error ? err.message : err}`
+      );
+      return "";
+    }
+  });
+}
+function encryptConfigSecrets(cfg, vault, _opts) {
+  return walk(cfg, vault, (v) => vault.encrypt(v));
+}
+function walk(node, vault, transform) {
+  if (node === null || node === void 0) return node;
+  if (typeof node !== "object") return node;
+  if (Array.isArray(node)) {
+    return node.map((item) => walk(item, vault, transform));
+  }
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const [k, v] of Object.entries(node)) {
+    if (typeof v === "string" && isSecretField(k)) {
+      out[k] = transform(v, k);
+    } else if (typeof v === "object" && v !== null) {
+      out[k] = walk(v, vault, transform);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+var SECRET_KEY_PATTERN = /(?:api[-_]?key|auth[-_]?token|authorization|proxy-authorization|cookie|bearer|secret|password|passwd|pwd|refresh[-_]?token|session[-_]?key|access[_-]?token|private[_-]?key|token\b)/i;
+var NON_SECRET_OVERRIDES = /* @__PURE__ */ new Set(["publickey", "public_key"]);
+function isSecretField(name) {
+  const lc = name.toLowerCase();
+  if (NON_SECRET_OVERRIDES.has(lc)) return false;
+  return SECRET_KEY_PATTERN.test(lc);
+}
+
+export {
+  decryptConfigSecrets,
+  encryptConfigSecrets,
+  isSecretField
+};
+//# sourceMappingURL=chunk-YY6APYUM.js.map