panopticon-cli 0.4.32 → 0.5.0

package/dist/chunk-GR6ZZMCX.js

@@ -0,0 +1,816 @@
+import {
+  createHumeConfig,
+  deleteHumeConfig,
+  init_hume
+} from "./chunk-7SN4L4PH.js";
+import {
+  collectSourceFiles,
+  compareFileToManifest,
+  hashFile,
+  init_manifest,
+  readManifest,
+  setManifestEntry,
+  writeManifest
+} from "./chunk-AQXETQHW.js";
+import {
+  CACHE_AGENTS_DIR,
+  CACHE_RULES_DIR,
+  SKILLS_DIR,
+  init_paths
+} from "./chunk-ZTFNYOC7.js";
+import {
+  addDnsEntry,
+  init_dns,
+  removeDnsEntry,
+  syncDnsToWindows
+} from "./chunk-JT4O4YVM.js";
+import {
+  addTunnelIngress,
+  init_tunnel,
+  removeTunnelIngress
+} from "./chunk-PELXV435.js";
+import {
+  getDefaultWorkspaceConfig,
+  init_workspace_config,
+  replacePlaceholders
+} from "./chunk-CWELWPWQ.js";
+import {
+  __esm,
+  init_esm_shims
+} from "./chunk-ZHC57RCV.js";
+
+// src/lib/skills-merge.ts
+import {
+  existsSync,
+  readdirSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  copyFileSync
+} from "fs";
+import { join, relative, dirname } from "path";
+function copyTree(sourceDir, targetDir) {
+  const copied = [];
+  if (!existsSync(sourceDir)) return copied;
+  function walk(dir) {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (entry.isFile()) {
+        const rel = relative(sourceDir, fullPath);
+        const targetPath = join(targetDir, rel);
+        mkdirSync(dirname(targetPath), { recursive: true });
+        copyFileSync(fullPath, targetPath);
+        copied.push(rel);
+      }
+    }
+  }
+  walk(sourceDir);
+  return copied;
+}
+function mergeSkillsIntoWorkspace(workspacePath) {
+  const claudeDir = join(workspacePath, ".claude");
+  const manifestPath = join(claudeDir, ".panopticon-manifest.json");
+  const manifest = readManifest(manifestPath);
+  const result = {
+    added: [],
+    updated: [],
+    skipped: [],
+    overlayed: []
+  };
+  mkdirSync(join(claudeDir, "skills"), { recursive: true });
+  mkdirSync(join(claudeDir, "agents"), { recursive: true });
+  const sources = [
+    { category: "skills", sourceDir: SKILLS_DIR, targetSubdir: "skills" },
+    { category: "agents", sourceDir: CACHE_AGENTS_DIR, targetSubdir: "agents" },
+    { category: "rules", sourceDir: CACHE_RULES_DIR, targetSubdir: "rules" }
+  ];
+  for (const { category, sourceDir, targetSubdir } of sources) {
+    if (!existsSync(sourceDir)) continue;
+    const prefix = targetSubdir ? `${targetSubdir}/` : "";
+    const files = collectSourceFiles(sourceDir, "");
+    for (const file of files) {
+      const relativePath = `${prefix}${file.relativePath}`;
+      const targetPath = join(claudeDir, relativePath);
+      const sourceHash = hashFile(file.absolutePath);
+      const status = compareFileToManifest(targetPath, relativePath, manifest);
+      switch (status.action) {
+        case "new":
+          mkdirSync(dirname(targetPath), { recursive: true });
+          copyFileSync(file.absolutePath, targetPath);
+          setManifestEntry(manifest, relativePath, sourceHash, "panopticon");
+          result.added.push(relativePath);
+          break;
+        case "update":
+          copyFileSync(file.absolutePath, targetPath);
+          setManifestEntry(manifest, relativePath, sourceHash, "panopticon");
+          result.updated.push(relativePath);
+          break;
+        case "modified":
+          result.skipped.push(`${relativePath} (modified by user)`);
+          break;
+        case "user-owned":
+          result.skipped.push(`${relativePath} (user-owned)`);
+          break;
+      }
+    }
+  }
+  writeManifest(manifestPath, manifest);
+  return result;
+}
+function applyProjectTemplateOverlay(workspacePath, templateDir, templates) {
+  const claudeDir = join(workspacePath, ".claude");
+  const manifestPath = join(claudeDir, ".panopticon-manifest.json");
+  const manifest = readManifest(manifestPath);
+  const overlayed = [];
+  if (!existsSync(templateDir)) return overlayed;
+  if (templates && templates.length > 0) {
+    for (const { source, target } of templates) {
+      const sourcePath = join(templateDir, source);
+      if (!existsSync(sourcePath)) continue;
+      const targetPath = join(workspacePath, target);
+      mkdirSync(dirname(targetPath), { recursive: true });
+      if (source.endsWith(".template")) {
+        continue;
+      }
+      copyFileSync(sourcePath, targetPath);
+      if (target.startsWith(".claude/")) {
+        const relativePath = target.slice(".claude/".length);
+        const hash = hashFile(targetPath);
+        setManifestEntry(manifest, relativePath, hash, "project-template");
+        overlayed.push(relativePath);
+      }
+    }
+  } else {
+    const claudeInTemplate = join(templateDir, ".claude");
+    if (existsSync(claudeInTemplate)) {
+      const copied = copyTree(claudeInTemplate, claudeDir);
+      for (const rel of copied) {
+        const targetPath = join(claudeDir, rel);
+        const hash = hashFile(targetPath);
+        setManifestEntry(manifest, rel, hash, "project-template");
+        overlayed.push(rel);
+      }
+    }
+  }
+  writeManifest(manifestPath, manifest);
+  return overlayed;
+}
+var init_skills_merge = __esm({
+  "src/lib/skills-merge.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_paths();
+    init_manifest();
+  }
+});
+
+// src/lib/workspace-manager.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, copyFileSync as copyFileSync2, symlinkSync, chmodSync, realpathSync } from "fs";
+import { join as join2, dirname as dirname2, basename, extname } from "path";
+import { homedir } from "os";
+import { exec } from "child_process";
+import { promisify } from "util";
+function createPlaceholders(projectConfig, featureName, workspacePath) {
+  const featureFolder = `feature-${featureName}`;
+  const domain = projectConfig.workspace?.dns?.domain || "localhost";
+  return {
+    FEATURE_NAME: featureName,
+    FEATURE_FOLDER: featureFolder,
+    BRANCH_NAME: `feature/${featureName}`,
+    COMPOSE_PROJECT: `${basename(projectConfig.path)}-${featureFolder}`,
+    DOMAIN: domain,
+    PROJECT_NAME: basename(projectConfig.path),
+    PROJECT_PATH: projectConfig.path,
+    WORKSPACE_PATH: workspacePath,
+    HOME: homedir()
+  };
+}
+function sanitizeComposeFile(filePath) {
+  if (!existsSync2(filePath)) return;
+  let content = readFileSync2(filePath, "utf-8");
+  const originalContent = content;
+  const homePatterns = [
+    /\/home\/[a-zA-Z0-9_-]+\//g,
+    // Linux: /home/username/
+    /\/Users\/[a-zA-Z0-9_-]+\//g
+    // macOS: /Users/username/
+  ];
+  for (const pattern of homePatterns) {
+    content = content.replace(pattern, "${HOME}/");
+  }
+  if (content !== originalContent) {
+    writeFileSync2(filePath, content, "utf-8");
+  }
+}
+function validateFeatureName(name) {
+  return /^[a-zA-Z0-9-]+$/.test(name);
+}
+async function createWorktree(repoPath, targetPath, branchName, defaultBranch = "main") {
+  try {
+    await execAsync("git fetch origin", { cwd: repoPath });
+    await execAsync("git worktree prune", { cwd: repoPath });
+    const { stdout: localBranches } = await execAsync("git branch --list", { cwd: repoPath });
+    const { stdout: remoteBranches } = await execAsync("git branch -r --list", { cwd: repoPath });
+    const branchExists = localBranches.includes(branchName) || remoteBranches.includes(`origin/${branchName}`);
+    if (branchExists) {
+      await execAsync(`git worktree add "${targetPath}" "${branchName}"`, { cwd: repoPath });
+    } else {
+      await execAsync(`git worktree add "${targetPath}" -b "${branchName}" "${defaultBranch}"`, { cwd: repoPath });
+    }
+    return { success: true, message: `Created worktree at ${targetPath}` };
+  } catch (error) {
+    return { success: false, message: `Failed to create worktree: ${error}` };
+  }
+}
+async function removeWorktree(repoPath, targetPath, branchName) {
+  try {
+    await execAsync(`git worktree remove "${targetPath}" --force`, { cwd: repoPath }).catch(() => {
+    });
+    await execAsync(`git branch -D "${branchName}"`, { cwd: repoPath }).catch(() => {
+    });
+    return { success: true, message: `Removed worktree at ${targetPath}` };
+  } catch (error) {
+    return { success: false, message: `Failed to remove worktree: ${error}` };
+  }
+}
+function assignPort(portFile, featureFolder, range) {
+  if (!existsSync2(portFile)) {
+    mkdirSync2(dirname2(portFile), { recursive: true });
+    writeFileSync2(portFile, "");
+  }
+  const content = readFileSync2(portFile, "utf-8");
+  const lines = content.split("\n").filter(Boolean);
+  for (const line of lines) {
+    const [folder, port] = line.split(":");
+    if (folder === featureFolder) {
+      return parseInt(port, 10);
+    }
+  }
+  const usedPorts = new Set(lines.map((l) => parseInt(l.split(":")[1], 10)));
+  for (let port = range[0]; port <= range[1]; port++) {
+    if (!usedPorts.has(port)) {
+      writeFileSync2(portFile, content + (content.endsWith("\n") ? "" : "\n") + `${featureFolder}:${port}
+`);
+      return port;
+    }
+  }
+  throw new Error(`No available ports in range ${range[0]}-${range[1]}`);
+}
+function releasePort(portFile, featureFolder) {
+  try {
+    if (!existsSync2(portFile)) return true;
+    let content = readFileSync2(portFile, "utf-8");
+    const lines = content.split("\n").filter((line) => !line.startsWith(`${featureFolder}:`));
+    writeFileSync2(portFile, lines.join("\n"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function processTemplates(templateDir, targetDir, placeholders, templates) {
+  const steps = [];
+  if (!existsSync2(templateDir)) {
+    return steps;
+  }
+  if (templates && templates.length > 0) {
+    for (const { source, target } of templates) {
+      const sourcePath = join2(templateDir, source);
+      const targetPath = join2(targetDir, target);
+      if (existsSync2(sourcePath)) {
+        const content = readFileSync2(sourcePath, "utf-8");
+        const processed = replacePlaceholders(content, placeholders);
+        mkdirSync2(dirname2(targetPath), { recursive: true });
+        writeFileSync2(targetPath, processed);
+        steps.push(`Processed template: ${source} -> ${target}`);
+      }
+    }
+  } else {
+    const files = readdirSync2(templateDir);
+    for (const file of files) {
+      if (file.endsWith(".template")) {
+        const sourcePath = join2(templateDir, file);
+        const targetPath = join2(targetDir, file.replace(".template", ""));
+        const content = readFileSync2(sourcePath, "utf-8");
+        const processed = replacePlaceholders(content, placeholders);
+        writeFileSync2(targetPath, processed);
+        steps.push(`Processed template: ${file}`);
+      }
+    }
+  }
+  return steps;
+}
+function copyProjectTemplateDirs(sourceDir, targetDir, dirs, placeholders) {
+  const steps = [];
+  for (const dir of dirs) {
+    let copyDir2 = function(src, dest) {
+      let count2 = 0;
+      mkdirSync2(dest, { recursive: true });
+      const entries = readdirSync2(src, { withFileTypes: true });
+      for (const entry of entries) {
+        const srcEntry = join2(src, entry.name);
+        const destEntry = join2(dest, entry.name);
+        if (entry.isDirectory()) {
+          count2 += copyDir2(srcEntry, destEntry);
+        } else if (entry.isFile()) {
+          const ext = extname(entry.name).toLowerCase();
+          if (placeholders && TEXT_EXTENSIONS.has(ext)) {
+            const content = readFileSync2(srcEntry, "utf-8");
+            writeFileSync2(destEntry, replacePlaceholders(content, placeholders));
+          } else {
+            copyFileSync2(srcEntry, destEntry);
+          }
+          count2++;
+        }
+      }
+      return count2;
+    };
+    var copyDir = copyDir2;
+    const sourcePath = join2(sourceDir, dir);
+    const targetPath = join2(targetDir, dir);
+    if (!existsSync2(sourcePath)) continue;
+    const count = copyDir2(sourcePath, targetPath);
+    steps.push(`Copied ${count} files from project template: ${dir}`);
+  }
+  return steps;
+}
+async function createWorkspace(options) {
+  const { projectConfig, featureName, startDocker, dryRun } = options;
+  const result = {
+    success: true,
+    workspacePath: "",
+    errors: [],
+    steps: []
+  };
+  if (!validateFeatureName(featureName)) {
+    result.success = false;
+    result.errors.push("Invalid feature name. Use alphanumeric and hyphens only.");
+    return result;
+  }
+  if (featureName === "main") {
+    result.success = false;
+    result.errors.push('Cannot create workspace for "main". Use base repos directly.');
+    return result;
+  }
+  const workspaceConfig = projectConfig.workspace || getDefaultWorkspaceConfig();
+  const workspacesDir = join2(projectConfig.path, workspaceConfig.workspaces_dir || "workspaces");
+  const featureFolder = `feature-${featureName}`;
+  const workspacePath = join2(workspacesDir, featureFolder);
+  result.workspacePath = workspacePath;
+  if (existsSync2(workspacePath)) {
+    result.success = false;
+    result.errors.push(`Workspace already exists at ${workspacePath}`);
+    return result;
+  }
+  if (dryRun) {
+    result.steps.push("[DRY RUN] Would create workspace at: " + workspacePath);
+    return result;
+  }
+  const placeholders = createPlaceholders(projectConfig, featureName, workspacePath);
+  mkdirSync2(workspacePath, { recursive: true });
+  result.steps.push("Created workspace directory");
+  if (workspaceConfig.type === "polyrepo" && workspaceConfig.repos) {
+    for (const repo of workspaceConfig.repos) {
+      const rawRepoPath = join2(projectConfig.path, repo.path);
+      const repoPath = existsSync2(rawRepoPath) ? realpathSync(rawRepoPath) : rawRepoPath;
+      const targetPath = join2(workspacePath, repo.name);
+      const branchPrefix = repo.branch_prefix || "feature/";
+      const branchName = `${branchPrefix}${featureName}`;
+      const defaultBranch = repo.default_branch || workspaceConfig.default_branch || "main";
+      const worktreeResult = await createWorktree(repoPath, targetPath, branchName, defaultBranch);
+      if (worktreeResult.success) {
+        result.steps.push(`Created worktree for ${repo.name}: ${branchName} (from ${defaultBranch})`);
+      } else {
+        result.errors.push(`${repo.name}: ${worktreeResult.message}`);
+        result.success = false;
+      }
+    }
+  } else {
+    const branchName = `feature/${featureName}`;
+    const defaultBranch = workspaceConfig.default_branch || "main";
+    const worktreeResult = await createWorktree(projectConfig.path, workspacePath, branchName, defaultBranch);
+    if (worktreeResult.success) {
+      result.steps.push(`Created worktree: ${branchName} (from ${defaultBranch})`);
+    } else {
+      result.errors.push(worktreeResult.message);
+      result.success = false;
+    }
+  }
+  const devcontainerDir = join2(workspacePath, ".devcontainer");
+  if (existsSync2(devcontainerDir)) {
+    const composeFiles = readdirSync2(devcontainerDir).filter((f) => f.includes("compose") && (f.endsWith(".yml") || f.endsWith(".yaml")));
+    for (const composeFile of composeFiles) {
+      sanitizeComposeFile(join2(devcontainerDir, composeFile));
+    }
+    if (composeFiles.length > 0) {
+      result.steps.push(`Sanitized ${composeFiles.length} compose file(s) for platform compatibility`);
+    }
+  }
+  try {
+    await execAsync("python3 --version");
+    const venvPath = join2(workspacePath, ".venv");
+    const tldrBin = join2(venvPath, "bin", "tldr");
+    const mainVenvTldr = join2(projectConfig.path, ".venv", "bin", "tldr");
+    const mainVenvExists = existsSync2(mainVenvTldr);
+    if (mainVenvExists) {
+      await execAsync(`cp -a "${join2(projectConfig.path, ".venv")}" "${venvPath}"`);
+      result.steps.push("Copied Python venv from main branch");
+    } else {
+      await execAsync(`python3 -m venv "${venvPath}"`, { cwd: workspacePath });
+      const pipPath = join2(venvPath, "bin", "pip");
+      await execAsync(`"${pipPath}" install llm-tldr`, { cwd: workspacePath, timeout: 12e4 });
+      result.steps.push("Created Python venv and installed llm-tldr");
+      const patchScript = join2(projectConfig.path, "scripts", "patches", "llm-tldr-tsx-support.py");
+      if (existsSync2(patchScript)) {
+        await execAsync(`python3 "${patchScript}" "${venvPath}"`);
+        result.steps.push("Applied llm-tldr .tsx/.jsx patch");
+      }
+    }
+    if (!existsSync2(tldrBin)) {
+      result.steps.push("TLDR setup incomplete: tldr binary not found after venv creation");
+    } else {
+      const mainTldrDir = join2(projectConfig.path, ".tldr");
+      const workspaceTldrDir = join2(workspacePath, ".tldr");
+      if (existsSync2(mainTldrDir)) {
+        await execAsync(`cp -r "${mainTldrDir}" "${workspaceTldrDir}"`);
+        result.steps.push("Copied TLDR index from main branch");
+      }
+      const { getTldrDaemonService } = await import("./tldr-daemon-T3THOUGT.js");
+      const tldrService = getTldrDaemonService(workspacePath, venvPath);
+      await tldrService.start(true);
+      result.steps.push("Started TLDR daemon");
+      try {
+        await tldrService.warm(true);
+        result.steps.push("TLDR index warm initiated (background)");
+      } catch {
+      }
+    }
+  } catch (error) {
+    if (error.message?.includes("python3")) {
+      result.steps.push("Skipped TLDR setup (python3 not available)");
+    } else {
+      console.warn(`\u26A0 TLDR setup failed: ${error.message}`);
+      result.steps.push(`TLDR setup failed: ${error.message}`);
+    }
+  }
+  if (workspaceConfig.dns) {
+    const dnsMethod = workspaceConfig.dns.sync_method || "wsl2hosts";
+    for (const entryPattern of workspaceConfig.dns.entries) {
+      const hostname = replacePlaceholders(entryPattern, placeholders);
+      if (addDnsEntry(dnsMethod, hostname)) {
+        result.steps.push(`Added DNS entry: ${hostname} (${dnsMethod})`);
+      }
+    }
+    if (dnsMethod === "wsl2hosts") {
+      const synced = await syncDnsToWindows();
+      if (synced) {
+        result.steps.push("Synced DNS to Windows hosts file");
+      }
+    }
+  }
+  if (workspaceConfig.ports) {
+    for (const [portName, portConfig] of Object.entries(workspaceConfig.ports)) {
+      const portFile = join2(projectConfig.path, `.${portName}-ports`);
+      try {
+        const port = assignPort(portFile, featureFolder, portConfig.range);
+        result.steps.push(`Assigned ${portName} port: ${port}`);
+        placeholders[`${portName.toUpperCase()}_PORT`] = String(port);
+      } catch (error) {
+        result.errors.push(`Failed to assign ${portName} port: ${error}`);
+      }
+    }
+  }
+  const mergeResult = mergeSkillsIntoWorkspace(workspacePath);
+  const mergeTotal = mergeResult.added.length + mergeResult.updated.length;
+  if (mergeTotal > 0) {
+    result.steps.push(`Installed ${mergeTotal} Panopticon files (${mergeResult.added.length} new, ${mergeResult.updated.length} updated)`);
+  }
+  if (workspaceConfig.agent?.template_dir) {
+    const templateDir = join2(projectConfig.path, workspaceConfig.agent.template_dir);
+    const templateSteps = processTemplates(
+      templateDir,
+      workspacePath,
+      placeholders,
+      workspaceConfig.agent.templates
+    );
+    result.steps.push(...templateSteps);
+    const dirsToSync = workspaceConfig.agent.copy_dirs || workspaceConfig.agent.symlinks;
+    if (dirsToSync) {
+      const copySteps = copyProjectTemplateDirs(templateDir, workspacePath, dirsToSync, placeholders);
+      result.steps.push(...copySteps);
+    }
+  }
+  if (workspaceConfig.env?.template) {
+    const envContent = replacePlaceholders(workspaceConfig.env.template, placeholders);
+    writeFileSync2(join2(workspacePath, ".env"), envContent);
+    result.steps.push("Created .env file");
+  }
+  if (workspaceConfig.docker?.compose_template) {
+    const templateDir = join2(projectConfig.path, workspaceConfig.docker.compose_template);
+    const devcontainerDir2 = join2(workspacePath, ".devcontainer");
+    mkdirSync2(devcontainerDir2, { recursive: true });
+    const templateSteps = processTemplates(templateDir, devcontainerDir2, placeholders);
+    result.steps.push(...templateSteps);
+    if (existsSync2(templateDir)) {
+      const files = readdirSync2(templateDir);
+      for (const file of files) {
+        if (!file.endsWith(".template")) {
+          const sourcePath = join2(templateDir, file);
+          const targetPath = join2(devcontainerDir2, file);
+          copyFileSync2(sourcePath, targetPath);
+        }
+      }
+    }
+    const composeFiles = readdirSync2(devcontainerDir2).filter((f) => f.includes("compose") && (f.endsWith(".yml") || f.endsWith(".yaml")));
+    for (const composeFile of composeFiles) {
+      sanitizeComposeFile(join2(devcontainerDir2, composeFile));
+    }
+    if (composeFiles.length > 0) {
+      result.steps.push(`Sanitized ${composeFiles.length} compose file(s) for platform compatibility`);
+    }
+    const devScriptInContainer = join2(devcontainerDir2, "dev");
+    const devScriptAtRoot = join2(workspacePath, "dev");
+    if (existsSync2(devScriptInContainer) && !existsSync2(devScriptAtRoot)) {
+      try {
+        symlinkSync(".devcontainer/dev", devScriptAtRoot);
+        chmodSync(devScriptInContainer, 493);
+        result.steps.push("Created ./dev symlink");
+      } catch (error) {
+        result.errors.push(`Failed to create ./dev symlink: ${error}`);
+      }
+    }
+  }
+  if (workspaceConfig.tunnel) {
+    const tunnelResult = await addTunnelIngress(workspaceConfig.tunnel, placeholders);
+    result.steps.push(...tunnelResult.steps);
+    if (!tunnelResult.success) {
+      result.errors.push("Tunnel setup had failures (see steps for details)");
+    }
+  }
+  if (workspaceConfig.hume) {
+    const humeResult = await createHumeConfig(workspaceConfig.hume, placeholders);
+    result.steps.push(...humeResult.steps);
+    if (humeResult.configId) {
+      writeFileSync2(
+        join2(workspacePath, ".hume-config"),
+        `HUME_CONFIG_ID=${humeResult.configId}
+VITE_HUME_CONFIG_ID=${humeResult.configId}
+`
+      );
+      result.steps.push("Wrote .hume-config with Hume EVI config ID");
+    }
+    if (!humeResult.success) {
+      result.errors.push("Hume EVI config setup had failures (see steps for details)");
+    }
+  }
+  if (startDocker) {
+    if (workspaceConfig.docker?.traefik) {
+      const traefikPath = join2(projectConfig.path, workspaceConfig.docker.traefik);
+      if (existsSync2(traefikPath)) {
+        try {
+          await execAsync(`docker compose -f "${traefikPath}" up -d`, { cwd: projectConfig.path });
+          result.steps.push("Started Traefik");
+        } catch (error) {
+          const msg = error?.message || String(error);
+          if (msg.includes("port is already allocated") || msg.includes("address already in use")) {
+            result.steps.push("Traefik already running (port in use)");
+          } else {
+            result.errors.push(`Failed to start Traefik: ${error}`);
+          }
+        }
+      }
+    }
+    const composeLocations = [
+      join2(workspacePath, "docker-compose.yml"),
+      join2(workspacePath, "docker-compose.yaml"),
+      join2(workspacePath, ".devcontainer", "docker-compose.yml"),
+      join2(workspacePath, ".devcontainer", "docker-compose.devcontainer.yml")
+    ];
+    for (const composePath of composeLocations) {
+      if (existsSync2(composePath)) {
+        try {
+          await execAsync(`docker compose -f "${composePath}" up -d --build`, { cwd: dirname2(composePath), timeout: 3e5 });
+          result.steps.push(`Started containers from ${basename(composePath)}`);
+        } catch (error) {
+          result.errors.push(`Failed to start containers: ${error}`);
+        }
+        break;
+      }
+    }
+  }
+  try {
+    preTrustDirectory(workspacePath);
+    result.steps.push("Pre-trusted workspace in Claude Code");
+  } catch {
+  }
+  result.success = result.errors.length === 0;
+  return result;
+}
+function preTrustDirectory(dirPath) {
+  const claudeJsonPath = join2(homedir(), ".claude.json");
+  if (!existsSync2(claudeJsonPath)) return;
+  const data = JSON.parse(readFileSync2(claudeJsonPath, "utf8"));
+  if (!data.projects) data.projects = {};
+  if (data.projects[dirPath]) {
+    if (!data.projects[dirPath].hasTrustDialogAccepted) {
+      data.projects[dirPath].hasTrustDialogAccepted = true;
+      writeFileSync2(claudeJsonPath, JSON.stringify(data, null, 2), "utf8");
+    }
+    return;
+  }
+  data.projects[dirPath] = {
+    allowedTools: [],
+    mcpContextUris: [],
+    mcpServers: {},
+    enabledMcpjsonServers: [],
+    disabledMcpjsonServers: [],
+    hasTrustDialogAccepted: true,
+    projectOnboardingSeenCount: 0,
+    hasClaudeMdExternalIncludesApproved: false,
+    hasClaudeMdExternalIncludesWarningShown: false
+  };
+  writeFileSync2(claudeJsonPath, JSON.stringify(data, null, 2), "utf8");
+}
+async function stopWorkspaceDocker(workspacePath, projectName, featureName) {
+  const result = {
+    containersFound: false,
+    steps: []
+  };
+  const devcontainerDir = join2(workspacePath, ".devcontainer");
+  const composeFiles = [];
+  if (existsSync2(devcontainerDir)) {
+    const possibleFiles = [
+      "docker-compose.devcontainer.yml",
+      "docker-compose.yml",
+      "compose.yml",
+      "compose.infra.yml",
+      "compose.override.yml"
+    ];
+    for (const file of possibleFiles) {
+      const fullPath = join2(devcontainerDir, file);
+      if (existsSync2(fullPath)) {
+        composeFiles.push(fullPath);
+      }
+    }
+  }
+  if (composeFiles.length === 0) {
+    const rootCompose = join2(workspacePath, "docker-compose.yml");
+    if (existsSync2(rootCompose)) {
+      composeFiles.push(rootCompose);
+    }
+  }
+  if (composeFiles.length > 0) {
+    result.containersFound = true;
+    try {
+      const fileFlags = composeFiles.map((f) => `-f "${f}"`).join(" ");
+      const cwd = existsSync2(devcontainerDir) ? devcontainerDir : workspacePath;
+      await execAsync(`docker compose ${fileFlags} down -v --remove-orphans`, {
+        cwd,
+        timeout: 6e4
+      });
+      result.steps.push(`Stopped Docker containers (${composeFiles.length} compose files)`);
+    } catch (error) {
+      result.steps.push(`Docker cleanup attempted (${error.message?.split("\n")[0] || "containers may not be running"})`);
+    }
+  }
+  try {
+    await execAsync(
+      `docker run --rm -v "${workspacePath}:/workspace" alpine sh -c "find /workspace -user root -delete 2>&1 | tail -100 || true"`,
+      { timeout: 3e4, maxBuffer: 10 * 1024 * 1024 }
+    );
+    result.steps.push("Cleaned up Docker-created files");
+  } catch {
+  }
+  return result;
+}
+async function removeWorkspace(options) {
+  const { projectConfig, featureName, dryRun } = options;
+  const result = {
+    success: true,
+    errors: [],
+    steps: []
+  };
+  const workspaceConfig = projectConfig.workspace || getDefaultWorkspaceConfig();
+  const workspacesDir = join2(projectConfig.path, workspaceConfig.workspaces_dir || "workspaces");
+  const featureFolder = `feature-${featureName}`;
+  const workspacePath = join2(workspacesDir, featureFolder);
+  if (!existsSync2(workspacePath)) {
+    result.success = false;
+    result.errors.push(`Workspace not found at ${workspacePath}`);
+    return result;
+  }
+  if (dryRun) {
+    result.steps.push("[DRY RUN] Would remove workspace at: " + workspacePath);
+    return result;
+  }
+  const venvPath = join2(workspacePath, ".venv");
+  if (existsSync2(venvPath)) {
+    try {
+      const { getTldrDaemonService } = await import("./tldr-daemon-T3THOUGT.js");
+      const tldrService = getTldrDaemonService(workspacePath, venvPath);
+      await tldrService.stop();
+      result.steps.push("Stopped TLDR daemon");
+    } catch (error) {
+      console.warn(`\u26A0 Failed to stop TLDR daemon: ${error?.message}`);
+    }
+  }
+  const dockerResult = await stopWorkspaceDocker(workspacePath, projectConfig.name || "workspace", featureName);
+  result.steps.push(...dockerResult.steps);
+  if (workspaceConfig.type === "polyrepo" && workspaceConfig.repos) {
+    for (const repo of workspaceConfig.repos) {
+      const repoPath = join2(projectConfig.path, repo.path);
+      const targetPath = join2(workspacePath, repo.name);
+      const branchPrefix = repo.branch_prefix || "feature/";
+      const branchName = `${branchPrefix}${featureName}`;
+      const worktreeResult = await removeWorktree(repoPath, targetPath, branchName);
+      if (worktreeResult.success) {
+        result.steps.push(`Removed worktree for ${repo.name}`);
+      } else {
+        result.errors.push(worktreeResult.message);
+      }
+    }
+  } else {
+    const branchName = `feature/${featureName}`;
+    const worktreeResult = await removeWorktree(projectConfig.path, workspacePath, branchName);
+    if (worktreeResult.success) {
+      result.steps.push("Removed worktree");
+    } else {
+      result.errors.push(worktreeResult.message);
+    }
+  }
+  if (workspaceConfig.dns) {
+    const placeholders = createPlaceholders(projectConfig, featureName, workspacePath);
+    const dnsMethod = workspaceConfig.dns.sync_method || "wsl2hosts";
+    for (const entryPattern of workspaceConfig.dns.entries) {
+      const hostname = replacePlaceholders(entryPattern, placeholders);
+      if (removeDnsEntry(dnsMethod, hostname)) {
+        result.steps.push(`Removed DNS entry: ${hostname}`);
+      }
+    }
+  }
+  if (workspaceConfig.tunnel) {
+    const placeholders = createPlaceholders(projectConfig, featureName, workspacePath);
+    const tunnelResult = await removeTunnelIngress(workspaceConfig.tunnel, placeholders);
+    result.steps.push(...tunnelResult.steps);
+  }
+  if (workspaceConfig.hume) {
+    const placeholders = createPlaceholders(projectConfig, featureName, workspacePath);
+    const humeResult = await deleteHumeConfig(workspaceConfig.hume, placeholders);
+    result.steps.push(...humeResult.steps);
+  }
+  if (workspaceConfig.ports) {
+    for (const [portName] of Object.entries(workspaceConfig.ports)) {
+      const portFile = join2(projectConfig.path, `.${portName}-ports`);
+      if (releasePort(portFile, featureFolder)) {
+        result.steps.push(`Released ${portName} port`);
+      }
+    }
+  }
+  try {
+    await execAsync(`rm -rf "${workspacePath}"`, { maxBuffer: 10 * 1024 * 1024 });
+    result.steps.push("Removed workspace directory");
+  } catch (error) {
+    result.errors.push(`Failed to remove workspace directory: ${error}`);
+  }
+  result.success = result.errors.length === 0;
+  return result;
+}
+var execAsync, TEXT_EXTENSIONS;
+var init_workspace_manager = __esm({
+  "src/lib/workspace-manager.ts"() {
+    init_esm_shims();
+    init_workspace_config();
+    init_dns();
+    init_tunnel();
+    init_hume();
+    init_skills_merge();
+    execAsync = promisify(exec);
+    TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".md",
+      ".sh",
+      ".yml",
+      ".yaml",
+      ".json",
+      ".ts",
+      ".js",
+      ".env",
+      ".txt",
+      ".toml",
+      ".template"
+    ]);
+  }
+});
+
+export {
+  mergeSkillsIntoWorkspace,
+  applyProjectTemplateOverlay,
+  init_skills_merge,
+  createWorkspace,
+  preTrustDirectory,
+  stopWorkspaceDocker,
+  removeWorkspace,
+  init_workspace_manager
+};
+//# sourceMappingURL=chunk-GR6ZZMCX.js.map