@sideboard-ai/core 0.1.9

package/dist/chunk-M37RITA6.js

@@ -0,0 +1,304 @@
+// src/store/paths.ts
+import { basename } from "path";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { mkdirSync } from "fs";
+
+// src/hook/settings.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { parse as parseToml } from "smol-toml";
+function expandHome(path) {
+  if (path.startsWith("~/") || path === "~") {
+    return join(homedir(), path.slice(2));
+  }
+  return path;
+}
+function parseAvailableIn(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const out = [];
+  for (const item of raw) {
+    if (item === "local" || item === "cloud") out.push(item);
+  }
+  return out.length ? out : void 0;
+}
+function parseSettingsFile(path, source) {
+  if (!existsSync(path)) return null;
+  const raw = readFileSync(path, "utf8");
+  const data = parseToml(raw);
+  const scripts = data.scripts ?? {};
+  const setup = typeof scripts.setup === "string" ? scripts.setup : void 0;
+  const archive = typeof scripts.archive === "string" ? scripts.archive : void 0;
+  const runMode = "run_mode" in scripts ? scripts.run_mode === "nonconcurrent" ? "nonconcurrent" : "concurrent" : void 0;
+  const filesToCopy = [];
+  const files = data.files;
+  if (Array.isArray(files?.copy)) {
+    filesToCopy.push(...files.copy.map(String));
+  }
+  const copySection = data["files-to-copy"];
+  if (Array.isArray(copySection?.paths)) {
+    filesToCopy.push(...copySection.paths.map(String));
+  }
+  const fileIncludeGlobs = [];
+  if (Array.isArray(data.file_include_globs)) {
+    fileIncludeGlobs.push(...data.file_include_globs.map(String));
+  }
+  const filesGlobs = files;
+  if (Array.isArray(filesGlobs?.include)) {
+    fileIncludeGlobs.push(...filesGlobs.include.map(String));
+  }
+  if (Array.isArray(filesGlobs?.include_globs)) {
+    fileIncludeGlobs.push(...filesGlobs.include_globs.map(String));
+  }
+  const runScripts = [];
+  const run = scripts.run;
+  if (typeof run === "string" && run.trim()) {
+    runScripts.push({ name: "dev", command: run, default: true });
+  } else if (run && typeof run === "object") {
+    for (const [name, value] of Object.entries(run)) {
+      if (value && typeof value.command === "string") {
+        runScripts.push({
+          name,
+          command: value.command,
+          default: Boolean(value.default),
+          icon: typeof value.icon === "string" ? value.icon : void 0,
+          availableIn: parseAvailableIn(value.available_in)
+        });
+      }
+    }
+  }
+  const worktrees = data.worktrees;
+  const worktreesRoot2 = typeof worktrees?.root === "string" ? expandHome(worktrees.root) : void 0;
+  const editor = typeof data.editor === "string" ? String(data.editor) : void 0;
+  const promptsRaw = data.prompts ?? {};
+  const prompts = {
+    renameBranch: typeof promptsRaw.rename_branch === "string" ? promptsRaw.rename_branch : void 0,
+    createPr: typeof promptsRaw.create_pr === "string" ? promptsRaw.create_pr : void 0,
+    general: typeof promptsRaw.general === "string" ? promptsRaw.general : void 0
+  };
+  const hasPrompts = Boolean(prompts.renameBranch || prompts.createPr || prompts.general);
+  return {
+    source,
+    setup,
+    archive,
+    runMode,
+    filesToCopy: filesToCopy.length ? filesToCopy : void 0,
+    fileIncludeGlobs: fileIncludeGlobs.length ? fileIncludeGlobs : void 0,
+    runScripts,
+    worktreesRoot: worktreesRoot2,
+    editor,
+    prompts: hasPrompts ? prompts : void 0
+  };
+}
+function mergeRunScripts(base, overlay) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const s of base) byName.set(s.name, s);
+  for (const s of overlay) byName.set(s.name, s);
+  return [...byName.values()];
+}
+function mergeSettings(base, overlay) {
+  if (!base) return overlay;
+  if (!overlay) return base;
+  const prompts = {
+    renameBranch: overlay.prompts?.renameBranch ?? base.prompts?.renameBranch,
+    createPr: overlay.prompts?.createPr ?? base.prompts?.createPr,
+    general: overlay.prompts?.general ?? base.prompts?.general
+  };
+  const hasPrompts = Boolean(prompts.renameBranch || prompts.createPr || prompts.general);
+  return {
+    source: overlay.source,
+    setup: overlay.setup ?? base.setup,
+    archive: overlay.archive ?? base.archive,
+    runMode: overlay.runMode ?? base.runMode,
+    filesToCopy: overlay.filesToCopy ?? base.filesToCopy,
+    fileIncludeGlobs: overlay.fileIncludeGlobs ?? base.fileIncludeGlobs,
+    runScripts: mergeRunScripts(base.runScripts, overlay.runScripts),
+    worktreesRoot: overlay.worktreesRoot ?? base.worktreesRoot,
+    editor: overlay.editor ?? base.editor,
+    prompts: hasPrompts ? prompts : void 0
+  };
+}
+function finalizeSettings(parsed) {
+  if (!parsed) return null;
+  return {
+    ...parsed,
+    runMode: parsed.runMode ?? "concurrent",
+    runScripts: parsed.runScripts
+  };
+}
+function familyFiles(rootPath, source) {
+  const dir = join(rootPath, `.${source}`);
+  return {
+    toml: join(dir, "settings.toml"),
+    local: join(dir, "settings.local.toml")
+  };
+}
+function familyExists(rootPath, source) {
+  const files = familyFiles(rootPath, source);
+  return existsSync(files.toml) || existsSync(files.local);
+}
+function detectFamily(rootPath) {
+  if (familyExists(rootPath, "sideboard")) return "sideboard";
+  if (familyExists(rootPath, "conductor")) return "conductor";
+  return null;
+}
+function loadCommittedToml(rootPath, source) {
+  return parseSettingsFile(familyFiles(rootPath, source).toml, source);
+}
+function loadLocalToml(rootPath, source) {
+  return parseSettingsFile(familyFiles(rootPath, source).local, source);
+}
+function loadAnyLocal(rootPath) {
+  return mergeSettings(
+    loadLocalToml(rootPath, "conductor"),
+    loadLocalToml(rootPath, "sideboard")
+  );
+}
+function normPath(p) {
+  return p.replace(/\/+$/, "");
+}
+function loadRepoSettings(repoPath) {
+  const family = detectFamily(repoPath);
+  if (!family) return null;
+  const merged = mergeSettings(
+    loadCommittedToml(repoPath, family),
+    loadLocalToml(repoPath, family)
+  );
+  return finalizeSettings(merged);
+}
+function loadWorkspaceSettings(worktreePath, repoPath) {
+  const wtFamily = detectFamily(worktreePath);
+  const repoFamily = repoPath && normPath(repoPath) !== normPath(worktreePath) ? detectFamily(repoPath) : null;
+  const wtToml = wtFamily ? loadCommittedToml(worktreePath, wtFamily) : null;
+  const repoToml = repoPath && repoFamily ? loadCommittedToml(repoPath, repoFamily) : null;
+  let merged = wtToml ?? repoToml;
+  if (repoPath && normPath(repoPath) !== normPath(worktreePath)) {
+    merged = mergeSettings(merged, loadAnyLocal(repoPath));
+  }
+  merged = mergeSettings(merged, loadAnyLocal(worktreePath));
+  return finalizeSettings(merged);
+}
+function loadConductorSettings(repoPath) {
+  return loadRepoSettings(repoPath);
+}
+function hasRepoHook(repoPath) {
+  return detectFamily(repoPath) !== null;
+}
+function hasWorkspaceHook(worktreePath, repoPath) {
+  if (hasRepoHook(worktreePath)) return true;
+  if (repoPath && normPath(repoPath) !== normPath(worktreePath) && hasRepoHook(repoPath)) {
+    return true;
+  }
+  return false;
+}
+function hasConductorHook(worktreePath, repoPath) {
+  return hasWorkspaceHook(worktreePath, repoPath);
+}
+function settingsSourceLabel(rootPath) {
+  const family = detectFamily(rootPath);
+  if (!family) return null;
+  const files = familyFiles(rootPath, family);
+  if (existsSync(files.toml) && existsSync(files.local)) {
+    return `.${family}/settings.toml + local`;
+  }
+  if (existsSync(files.local)) return `.${family}/settings.local.toml`;
+  return `.${family}/settings.toml`;
+}
+function workspaceSettingsSourceLabel(worktreePath, repoPath) {
+  const wt = settingsSourceLabel(worktreePath);
+  if (wt) return `${wt} (worktree)`;
+  if (repoPath && normPath(repoPath) !== normPath(worktreePath)) {
+    const repo = settingsSourceLabel(repoPath);
+    if (repo) return `${repo} (main repo)`;
+  }
+  return null;
+}
+function getRepoSetupInfo(worktreePath, repoPath) {
+  const settings = loadWorkspaceSettings(worktreePath, repoPath);
+  return {
+    hasConfig: hasWorkspaceHook(worktreePath, repoPath),
+    hasSetupScript: Boolean(settings?.setup),
+    configLabel: workspaceSettingsSourceLabel(worktreePath, repoPath)
+  };
+}
+
+// src/store/paths.ts
+function appDataDir() {
+  const override = process.env.SIDEBOARD_APP_DATA?.trim();
+  const base = override ? override : process.platform === "darwin" ? join2(homedir2(), "Library", "Application Support", "sideboard") : process.platform === "win32" ? join2(process.env.APPDATA ?? join2(homedir2(), "AppData", "Roaming"), "sideboard") : join2(homedir2(), ".local", "share", "sideboard");
+  mkdirSync(base, { recursive: true });
+  return base;
+}
+function threadsDir() {
+  const dir = join2(appDataDir(), "threads");
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function locksDir() {
+  const dir = join2(appDataDir(), "locks");
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function sideboardHomeDir() {
+  const dir = join2(homedir2(), "sideboard");
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function sideboardReposDir() {
+  const dir = join2(sideboardHomeDir(), "repos");
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function sideboardWorkspacesDir() {
+  const dir = join2(sideboardHomeDir(), "workspaces");
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function repoSlug(repoPath) {
+  return basename(repoPath.replace(/\/$/, "")) || "repo";
+}
+function worktreesRoot(repoPath) {
+  const settings = loadRepoSettings(repoPath);
+  if (settings?.worktreesRoot) {
+    mkdirSync(settings.worktreesRoot, { recursive: true });
+    return settings.worktreesRoot;
+  }
+  const dir = join2(sideboardWorkspacesDir(), repoSlug(repoPath));
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function threadFilePath(id) {
+  return join2(threadsDir(), `${id}.json`);
+}
+function threadLockPath(id) {
+  return join2(locksDir(), `${id}.lock`);
+}
+function globalAgentCwd() {
+  const dir = join2(appDataDir(), "global");
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export {
+  loadRepoSettings,
+  loadWorkspaceSettings,
+  loadConductorSettings,
+  hasRepoHook,
+  hasWorkspaceHook,
+  hasConductorHook,
+  settingsSourceLabel,
+  workspaceSettingsSourceLabel,
+  getRepoSetupInfo,
+  appDataDir,
+  threadsDir,
+  locksDir,
+  sideboardHomeDir,
+  sideboardReposDir,
+  sideboardWorkspacesDir,
+  repoSlug,
+  worktreesRoot,
+  threadFilePath,
+  threadLockPath,
+  globalAgentCwd
+};

package/dist/chunk-TLJH3L2C.js

@@ -0,0 +1,80 @@
+import {
+  isGlobalRepoPath
+} from "./chunk-2M4OHXYX.js";
+import {
+  resolveRepoRoot
+} from "./chunk-LL7DTZ5B.js";
+import {
+  appDataDir
+} from "./chunk-M37RITA6.js";
+
+// src/store/workspaces.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { basename, join } from "path";
+function workspacesFile() {
+  return join(appDataDir(), "workspaces.json");
+}
+function readAll() {
+  const path = workspacesFile();
+  if (!existsSync(path)) return [];
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf8"));
+    return Array.isArray(raw) ? raw : [];
+  } catch {
+    return [];
+  }
+}
+function writeAll(list) {
+  mkdirSync(appDataDir(), { recursive: true });
+  writeFileSync(workspacesFile(), JSON.stringify(list, null, 2), "utf8");
+}
+function listWorkspaces() {
+  return readAll().sort((a, b) => a.name.localeCompare(b.name));
+}
+async function addWorkspace(repoPath) {
+  const root = await resolveRepoRoot(repoPath);
+  if (!existsSync(root)) throw new Error(`Repo not found: ${root}`);
+  const current = readAll();
+  const existing = current.find((w) => w.path === root);
+  if (existing) return existing;
+  const next = {
+    path: root,
+    name: basename(root),
+    addedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeAll([...current, next]);
+  return next;
+}
+function removeWorkspace(repoPath) {
+  writeAll(readAll().filter((w) => w.path !== repoPath));
+}
+async function ensureWorkspace(repoPath) {
+  return addWorkspace(repoPath);
+}
+function syncWorkspacesFromThreads(repoPaths) {
+  const current = readAll();
+  const byPath = new Map(current.map((w) => [w.path, w]));
+  let dirty = false;
+  for (const path of repoPaths) {
+    if (!path || isGlobalRepoPath(path) || byPath.has(path)) continue;
+    if (!existsSync(path)) continue;
+    const ws = {
+      path,
+      name: basename(path),
+      addedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    byPath.set(path, ws);
+    dirty = true;
+  }
+  const next = [...byPath.values()];
+  if (dirty) writeAll(next);
+  return next.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export {
+  listWorkspaces,
+  addWorkspace,
+  removeWorkspace,
+  ensureWorkspace,
+  syncWorkspacesFromThreads
+};