@wrongstack/core 0.310.1 → 0.313.1

package/dist/chunk-JTHKOYWU.js

@@ -0,0 +1,663 @@
+import {
+  DefaultConfigLoader
+} from "./chunk-IQ35HMQL.js";
+import {
+  DefaultSecretVault,
+  migratePlaintextSecrets
+} from "./chunk-6AKOTGLM.js";
+import {
+  DefaultLogger,
+  noOpLogger
+} from "./chunk-WBPVKEEE.js";
+import {
+  promptCacheHitRatio
+} from "./chunk-NFAYHPRH.js";
+import {
+  activateProjectStateGuard
+} from "./chunk-CQQL4ZOQ.js";
+import {
+  safeParse
+} from "./chunk-RPOA7IAE.js";
+import {
+  ensureProjectGitignore,
+  ensureProjectIdentity,
+  readProjectIdentity
+} from "./chunk-4XV6IR37.js";
+import {
+  writeErr
+} from "./chunk-4VWO3ZXL.js";
+import {
+  atomicWrite
+} from "./chunk-7ZHZE5EO.js";
+import {
+  canonicalProjectRoot,
+  resolveWstackPaths,
+  safeProfileName
+} from "./chunk-YNCVSFGF.js";
+import {
+  normalizeTokenSavingTier
+} from "./chunk-KJ2ZTQSL.js";
+import {
+  toErrorMessage
+} from "./chunk-TBRL2RCC.js";
+
+// src/infrastructure/path-resolver.ts
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+var PROJECT_MARKERS = [
+  ".git",
+  "package.json",
+  "pnpm-workspace.yaml",
+  "go.mod",
+  "Cargo.toml",
+  "pyproject.toml",
+  // Use AGENTS.md, not the bare .wrongstack directory.  A bare .wrongstack/
+  // directory can be the global config directory (~/.wrongstack), which is
+  // NOT a project marker.  Only .wrongstack/AGENTS.md signals a real
+  // WrongStack project.
+  ".wrongstack/AGENTS.md"
+];
+var DefaultPathResolver = class {
+  projectRoot;
+  cwd;
+  constructor(cwd = process.cwd()) {
+    this.cwd = path.resolve(cwd);
+    this.projectRoot = this.detectProjectRoot(this.cwd);
+  }
+  detectProjectRoot(start) {
+    let dir = path.resolve(start);
+    const root = path.parse(dir).root;
+    const home = path.resolve(os.homedir());
+    const startPath = path.resolve(start);
+    while (dir !== root) {
+      if (dir === home && dir !== startPath) {
+        break;
+      }
+      for (const marker of PROJECT_MARKERS) {
+        try {
+          fs.accessSync(path.join(dir, marker));
+          return dir;
+        } catch {
+        }
+      }
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    return startPath;
+  }
+  resolve(input) {
+    const abs = path.isAbsolute(input) ? input : path.resolve(this.cwd, input);
+    let real;
+    try {
+      real = fs.realpathSync(abs);
+    } catch {
+      real = path.normalize(abs);
+    }
+    return real;
+  }
+  isInsideRoot(absPath) {
+    const normalized = path.normalize(absPath);
+    const root = path.normalize(this.projectRoot);
+    if (normalized === root) return true;
+    const rel = path.relative(root, normalized);
+    return !rel.startsWith("..") && !path.isAbsolute(rel);
+  }
+  ensureInsideRoot(absPath) {
+    const resolved = this.resolve(absPath);
+    if (!this.isInsideRoot(resolved)) {
+      const display = path.isAbsolute(absPath) ? path.basename(absPath) : absPath;
+      const err = new Error(`Path "${display}" resolves outside the project root`);
+      err.fullPath = absPath;
+      err.projectRoot = this.projectRoot;
+      throw err;
+    }
+    return resolved;
+  }
+};
+
+// src/boot.ts
+import * as fs2 from "node:fs/promises";
+import * as os2 from "node:os";
+import * as path2 from "node:path";
+async function bootConfig(options = {}) {
+  const {
+    flags = {},
+    appLabel = "wstack",
+    loadSyncConfig = true,
+    skipIdentityValidation = false
+  } = options;
+  const cwd = typeof flags["cwd"] === "string" ? path2.resolve(flags["cwd"]) : process.cwd();
+  const pathResolver = new DefaultPathResolver(cwd);
+  const projectRoot = pathResolver.projectRoot;
+  const projectIdentityRoot = canonicalProjectRoot(projectRoot);
+  const userHome = os2.homedir();
+  const wpaths = resolveWstackPaths({ projectRoot });
+  assertProjectRootOutsideStateDir(projectRoot, wpaths.globalRoot);
+  await activateProjectStateGuard(projectRoot);
+  await fs2.mkdir(wpaths.globalRoot, { recursive: true });
+  await fs2.mkdir(wpaths.profilesDir, { recursive: true });
+  await fs2.mkdir(wpaths.projectDir, { recursive: true });
+  await fs2.mkdir(wpaths.projectSessions, { recursive: true });
+  let registeredProjectId;
+  try {
+    registeredProjectId = (await readProjectIdentity(projectRoot))?.projectId;
+  } catch {
+  }
+  await writeProjectMeta(wpaths, projectIdentityRoot, registeredProjectId);
+  await registerProjectInManifest(
+    wpaths,
+    projectIdentityRoot,
+    void 0,
+    cwd !== projectIdentityRoot ? cwd : void 0,
+    registeredProjectId
+  );
+  await ensureProjectGitignore(projectRoot).catch(() => void 0);
+  await migrateLegacyConfig(wpaths);
+  await migrateProfileFiles(wpaths);
+  cleanupStaleProjects(wpaths).catch((err) => {
+    noOpLogger.debug("cleanupStaleProjects failed", { err });
+  });
+  const bootLogger = new DefaultLogger({ stderr: true });
+  const vault = new DefaultSecretVault({ keyFile: wpaths.secretsKey, logger: bootLogger });
+  const bootstrapProfilePath = typeof wpaths.profileConfig === "function" ? wpaths.profileConfig(wpaths.profileName) : null;
+  const secretFiles = [wpaths.projectLocalConfig].filter(Boolean);
+  if (bootstrapProfilePath) secretFiles.push(bootstrapProfilePath);
+  for (const file of secretFiles) {
+    try {
+      const { migrated } = await migratePlaintextSecrets(file, vault, noOpLogger);
+      if (migrated > 0) {
+        writeErr(`[${appLabel}] Encrypted ${migrated} plaintext secret(s) in ${file}
+`);
+      }
+    } catch {
+    }
+  }
+  const configLoader = new DefaultConfigLoader({ paths: wpaths, vault, logger: bootLogger });
+  let config;
+  try {
+    config = await configLoader.load({ cliFlags: flagsToConfigPatch(flags) });
+  } catch (err) {
+    if (skipIdentityValidation && err instanceof Error && err.message.includes("no provider configured")) {
+      console.warn(
+        JSON.stringify({
+          level: "warn",
+          event: "boot.no_provider_configured",
+          app: appLabel,
+          message: "No provider configured \u2014 setup screen will be shown",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+      try {
+        config = await configLoader.load({
+          cliFlags: flagsToConfigPatch(flags),
+          skipIdentityValidation: true
+        });
+      } catch (fallbackErr) {
+        console.warn(
+          JSON.stringify({
+            level: "warn",
+            event: "boot.config_fallback",
+            message: `Config load fallback triggered: ${toErrorMessage(fallbackErr)}`,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
+        config = Object.freeze({});
+      }
+    } else {
+      throw err;
+    }
+  }
+  if (loadSyncConfig) {
+    const syncConfig = await configLoader.loadSyncConfig();
+    if (syncConfig) {
+      config = Object.freeze({ ...config, sync: syncConfig });
+    }
+  }
+  if (!config.hq?.projectAlias) {
+    try {
+      await ensureProjectIdentity(projectRoot);
+    } catch (error) {
+      bootLogger.warn?.("Could not initialize .wrongstack/project.json", {
+        event: "project.identity_init_failed",
+        error: toErrorMessage(error)
+      });
+    }
+  }
+  let committedProjectId;
+  try {
+    committedProjectId = (await readProjectIdentity(projectRoot))?.projectId;
+  } catch {
+  }
+  if (committedProjectId !== registeredProjectId) {
+    await writeProjectMeta(wpaths, projectIdentityRoot, committedProjectId);
+    await registerProjectInManifest(
+      wpaths,
+      projectIdentityRoot,
+      void 0,
+      cwd !== projectIdentityRoot ? cwd : void 0,
+      committedProjectId
+    );
+  }
+  const logger = new DefaultLogger({ level: config.log?.level ?? "info", file: wpaths.logFile });
+  try {
+    const { getProjectSessionRegistry } = await import("./registry-R23UBE7H.js");
+    getProjectSessionRegistry(wpaths.globalRoot);
+  } catch {
+  }
+  return {
+    cwd,
+    projectRoot,
+    userHome,
+    wpaths,
+    pathResolver,
+    config,
+    vault,
+    logger,
+    globalConfigPath: wpaths.globalConfig
+  };
+}
+function isEnabledFlag(value) {
+  if (value === true) return true;
+  if (typeof value !== "string") return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "on";
+}
+function flagsToConfigPatch(flags) {
+  const patch = {};
+  if (typeof flags["provider"] === "string") patch.provider = flags["provider"];
+  if (typeof flags["model"] === "string") patch.model = flags["model"];
+  if (typeof flags["fallback-model"] === "string") {
+    const list = flags["fallback-model"].split(",").map((s) => s.trim()).filter(Boolean);
+    if (list.length > 0) patch.fallbackModels = list;
+  }
+  if (typeof flags["cwd"] === "string") patch.cwd = flags["cwd"];
+  if (typeof flags["log-level"] === "string") {
+    patch.log = { level: flags["log-level"] };
+  } else if (flags["verbose"]) {
+    patch.log = { level: "debug" };
+  } else if (flags["trace"]) {
+    patch.log = { level: "trace" };
+  }
+  if (flags["no-yolo"] === true) patch.yolo = false;
+  else if (flags["yolo"]) patch.yolo = true;
+  if (flags["no-features"]) {
+    patch.features = {
+      mcp: false,
+      plugins: false,
+      memory: false,
+      modelsRegistry: false,
+      skills: false
+    };
+  }
+  if (flags["token-saving-mode"]) {
+    patch.features ??= {};
+    patch.features.tokenSavingMode = true;
+  }
+  if (isEnabledFlag(flags["system-pro"]) || flags["system-prompt"] === "pro") {
+    patch.systemPrompt = { variant: "pro" };
+  } else if (isEnabledFlag(flags["system-lite"]) || flags["system-prompt"] === "lite") {
+    patch.systemPrompt = { variant: "lite" };
+  } else if (flags["system-prompt"] === "default") {
+    patch.systemPrompt = { variant: "default" };
+  }
+  if (typeof flags["token-saving-tier"] === "string") {
+    patch.features ??= {};
+    patch.features.tokenSavingMode = normalizeTokenSavingTier(
+      flags["token-saving-tier"]
+    );
+  }
+  return patch;
+}
+async function migrateLegacyConfig(wpaths) {
+  const rootFp = wpaths.globalConfig;
+  let legacyRaw;
+  try {
+    legacyRaw = await fs2.readFile(rootFp, "utf8");
+  } catch {
+    return;
+  }
+  const result = safeParse(legacyRaw);
+  if (!result.ok || !result.value || typeof result.value !== "object" || Array.isArray(result.value)) {
+    return;
+  }
+  const activeProfile = safeProfileName(
+    typeof result.value["activeProfile"] === "string" ? result.value["activeProfile"] : void 0
+  );
+  const profileFp = wpaths.profileConfig(activeProfile);
+  try {
+    await fs2.access(profileFp);
+    return;
+  } catch (err) {
+    if (err.code !== "ENOENT") return;
+  }
+  await fs2.mkdir(path2.dirname(profileFp), { recursive: true });
+  const profileContent = { ...result.value };
+  delete profileContent["activeProfile"];
+  await atomicWrite(profileFp, JSON.stringify(profileContent, null, 2), { mode: 384 });
+  const bootstrap = { version: 1, activeProfile };
+  try {
+    await atomicWrite(rootFp, JSON.stringify(bootstrap, null, 2), { mode: 384 });
+  } catch {
+  }
+}
+var PROFILE_STATE_PAIRS = [
+  {
+    globalSrc: (w) => path2.join(w.globalRoot, "statusline.json"),
+    profileDst: (w, n) => w.profileStatuslineConfig(n)
+  },
+  {
+    globalSrc: (w) => path2.join(w.globalRoot, "mode.json"),
+    profileDst: (w, n) => w.profileModeConfig(n)
+  },
+  {
+    globalSrc: (w) => path2.join(w.globalRoot, "provider-status.json"),
+    profileDst: (w, n) => w.profileProviderStatus(n)
+  },
+  {
+    globalSrc: (w) => path2.join(w.globalRoot, "update-cache.json"),
+    profileDst: (w, n) => w.profileUpdateCache(n)
+  },
+  {
+    globalSrc: (w) => path2.join(w.globalRoot, "memory.md"),
+    profileDst: (w, n) => path2.join(w.profilesDir, n, "memory.md")
+  },
+  {
+    globalSrc: (w) => path2.join(w.globalRoot, "history"),
+    profileDst: (w, n) => path2.join(w.profilesDir, n, "history")
+  },
+  {
+    globalSrc: (w) => path2.join(w.globalRoot, "sync.json"),
+    profileDst: (w, n) => path2.join(w.profilesDir, n, "sync.json")
+  },
+  {
+    globalSrc: (w) => path2.join(w.globalRoot, "sync-state.json"),
+    profileDst: (w, n) => path2.join(w.profilesDir, n, "sync-state.json")
+  },
+  {
+    globalSrc: (w) => path2.join(w.globalRoot, "prompt-usage.json"),
+    profileDst: (w, n) => path2.join(w.profilesDir, n, "prompt-usage.json")
+  },
+  {
+    globalSrc: (w) => path2.join(w.globalRoot, "custom-context-modes.json"),
+    profileDst: (w, n) => path2.join(w.profilesDir, n, "custom-context-modes.json")
+  },
+  {
+    globalSrc: (w) => path2.join(w.globalRoot, "desktop.json"),
+    profileDst: (w, n) => path2.join(w.profilesDir, n, "desktop.json")
+  },
+  {
+    globalSrc: (w) => path2.join(w.globalRoot, "installed-skills.json"),
+    profileDst: (w, n) => path2.join(w.profilesDir, n, "installed-skills.json")
+  },
+  ...["skills", "prompts", "instructions", "design-kits", "desktop", "settings"].map(
+    (directory) => ({
+      globalSrc: (w) => path2.join(w.globalRoot, directory),
+      profileDst: (w, n) => path2.join(w.profilesDir, n, directory)
+    })
+  )
+];
+async function migrateProfileFiles(wpaths) {
+  let profileName = wpaths.profileName;
+  try {
+    const raw = await fs2.readFile(wpaths.globalConfig, "utf8");
+    const parsed = safeParse(raw);
+    if (parsed.ok && parsed.value && typeof parsed.value.activeProfile === "string") {
+      profileName = safeProfileName(parsed.value.activeProfile);
+    }
+  } catch {
+  }
+  try {
+    await fs2.mkdir(path2.join(wpaths.profilesDir, profileName), { recursive: true });
+  } catch {
+    return;
+  }
+  for (const pair of PROFILE_STATE_PAIRS) {
+    const src = pair.globalSrc(wpaths);
+    const dst = pair.profileDst(wpaths, profileName);
+    let srcIsDir;
+    try {
+      srcIsDir = (await fs2.stat(src)).isDirectory();
+    } catch {
+      continue;
+    }
+    try {
+      const dstStat = await fs2.stat(dst);
+      if (dstStat.isDirectory() === srcIsDir) {
+        continue;
+      }
+      await fs2.rm(dst, { recursive: true, force: true });
+    } catch (err) {
+      const code = err.code;
+      if (code !== "ENOENT") {
+        writeErr(`migrateProfileFiles: skipping ${dst} (stat error: ${code ?? "unknown"})
+`);
+        continue;
+      }
+    }
+    try {
+      if (srcIsDir) {
+        await fs2.cp(src, dst, { recursive: true, errorOnExist: false, force: false });
+      } else {
+        const content = await fs2.readFile(src);
+        await fs2.writeFile(dst, content, { mode: 384 });
+      }
+    } catch {
+    }
+  }
+}
+function assertProjectRootOutsideStateDir(projectRoot, globalRoot) {
+  const stateNamespace = path2.resolve(globalRoot, "projects");
+  const rel = path2.relative(stateNamespace, path2.resolve(projectRoot));
+  if (rel.startsWith("..") || path2.isAbsolute(rel)) return;
+  throw new Error(
+    `Refusing to start: the resolved project root is inside WrongStack's per-project state directory.
+  project root: ${projectRoot}
+  state dir:    ${stateNamespace}
+This usually means a WrongStack process was spawned with a state path as its working directory. Start from a real project directory, or pass --cwd <path>.`
+  );
+}
+async function writeProjectMeta(paths, projectRoot, projectId) {
+  try {
+    await fs2.mkdir(paths.projectDir, { recursive: true });
+    const meta = {
+      hash: paths.projectHash,
+      slug: paths.projectSlug,
+      root: projectRoot,
+      ...projectId ? { projectId } : {},
+      lastSeen: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await atomicWrite(paths.projectMeta, JSON.stringify(meta, null, 2));
+  } catch {
+  }
+}
+async function registerProjectInManifest(paths, projectRoot, events, workingDir, projectId) {
+  const manifestPath = path2.join(paths.globalRoot, "projects.json");
+  try {
+    const t0 = Date.now();
+    const raw = await fs2.readFile(manifestPath, "utf8");
+    events?.emit("storage.read", {
+      sessionId: "~boot~",
+      store: "project",
+      filePath: manifestPath,
+      operation: "manifest_read",
+      outcome: "success",
+      durationMs: Date.now() - t0
+    });
+    try {
+      JSON.parse(raw);
+    } catch {
+    }
+  } catch (err) {
+    events?.emit("storage.error", {
+      sessionId: "~boot~",
+      store: "project",
+      filePath: manifestPath,
+      operation: "manifest_read",
+      error: toErrorMessage(err),
+      recoverable: true
+    });
+  }
+  try {
+    let manifest;
+    try {
+      const raw = await fs2.readFile(manifestPath, "utf8");
+      manifest = JSON.parse(raw);
+    } catch {
+      manifest = { projects: [] };
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = manifest.projects.find((p) => p.root === projectRoot);
+    if (existing) {
+      existing.lastSeen = now;
+      if (projectId) existing.projectId = projectId;
+      if (workingDir) existing.lastWorkingDir = workingDir;
+    } else {
+      const slug = paths.projectSlug;
+      const name = path2.basename(projectRoot);
+      const entry = {
+        name,
+        root: projectRoot,
+        slug,
+        projectId,
+        lastSeen: now,
+        createdAt: now
+      };
+      if (workingDir) entry.lastWorkingDir = workingDir;
+      manifest.projects.push(entry);
+    }
+    const writeT0 = Date.now();
+    await atomicWrite(manifestPath, JSON.stringify(manifest, null, 2));
+    events?.emit("storage.write", {
+      sessionId: "~boot~",
+      store: "project",
+      filePath: manifestPath,
+      operation: "manifest_write",
+      outcome: "success",
+      durationMs: Date.now() - writeT0
+    });
+  } catch (err) {
+    events?.emit("storage.error", {
+      sessionId: "~boot~",
+      store: "project",
+      filePath: manifestPath,
+      operation: "manifest_write",
+      error: toErrorMessage(err),
+      recoverable: false
+    });
+  }
+}
+async function cleanupStaleProjects(wpaths) {
+  const projectsRoot = path2.dirname(wpaths.projectDir);
+  let entries;
+  try {
+    entries = await fs2.readdir(projectsRoot, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const stateNamespace = path2.resolve(projectsRoot);
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const projectPath = path2.join(projectsRoot, entry.name);
+    const metaPath = path2.join(projectPath, "meta.json");
+    try {
+      const raw = await fs2.readFile(metaPath, "utf8");
+      const meta = JSON.parse(raw);
+      if (typeof meta.root !== "string") continue;
+      const rel = path2.relative(stateNamespace, path2.resolve(meta.root));
+      const nested = rel !== "" && !rel.startsWith("..") && !path2.isAbsolute(rel);
+      if (nested) {
+        await fs2.rm(projectPath, { recursive: true, force: true });
+        continue;
+      }
+      try {
+        await fs2.access(meta.root);
+      } catch {
+        await fs2.rm(projectPath, { recursive: true, force: true });
+      }
+    } catch {
+    }
+  }
+}
+
+// src/infrastructure/provider-cache-ledger.ts
+var ProviderCacheLedger = class {
+  byProvider = /* @__PURE__ */ new Map();
+  last = { input: 0, cacheRead: 0, cacheWrite: 0 };
+  off;
+  constructor(events) {
+    this.off = events.on(
+      "token.accounted",
+      (p) => {
+        this.record(p.usage, p.provider, p.deltaUsage);
+      }
+    );
+  }
+  record(usage, provider, deltaUsage) {
+    const cur = {
+      input: usage.input,
+      cacheRead: usage.cacheRead ?? 0,
+      cacheWrite: usage.cacheWrite ?? 0
+    };
+    const delta = deltaUsage ? {
+      input: deltaUsage.input,
+      cacheRead: deltaUsage.cacheRead ?? 0,
+      cacheWrite: deltaUsage.cacheWrite ?? 0
+    } : {
+      input: Math.max(0, cur.input - this.last.input),
+      cacheRead: Math.max(0, cur.cacheRead - this.last.cacheRead),
+      cacheWrite: Math.max(0, cur.cacheWrite - this.last.cacheWrite)
+    };
+    this.last = cur;
+    const key = provider ?? "unknown";
+    const acc = this.byProvider.get(key) ?? { input: 0, cacheRead: 0, cacheWrite: 0 };
+    acc.input += delta.input;
+    acc.cacheRead += delta.cacheRead;
+    acc.cacheWrite += delta.cacheWrite;
+    this.byProvider.set(key, acc);
+  }
+  /** Distinct providers seen this session. */
+  providers() {
+    return [...this.byProvider.keys()];
+  }
+  /** Per-provider cache stats, most-cached first. */
+  perProvider() {
+    const out = [];
+    for (const [provider, a] of this.byProvider) {
+      out.push({
+        provider,
+        input: a.input,
+        cacheRead: a.cacheRead,
+        cacheWrite: a.cacheWrite,
+        hitRatio: promptCacheHitRatio({
+          input: a.input,
+          output: 0,
+          cacheRead: a.cacheRead,
+          cacheWrite: a.cacheWrite
+        })
+      });
+    }
+    return out.sort((x, y) => y.cacheRead - x.cacheRead);
+  }
+  /**
+   * Unsubscribe from the event bus and release the per-session listener.
+   *
+   * **The caller MUST invoke `dispose()` on session teardown** — see the
+   * constructor's lifecycle warning. Failure to call this method leaves a
+   * permanent `token.accounted` listener on the shared EventBus that
+   * accumulates unboundedly across session restarts/resumes.
+   */
+  dispose() {
+    this.off();
+  }
+};
+
+export {
+  DefaultPathResolver,
+  bootConfig,
+  flagsToConfigPatch,
+  assertProjectRootOutsideStateDir,
+  ProviderCacheLedger
+};
+//# sourceMappingURL=chunk-JTHKOYWU.js.map