totopo 0.5.0 → 0.6.0-rc-2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "totopo",
-  "version": "0.5.0",
+  "version": "0.6.0-rc-2",
   "description": "Secure AI Box — isolated dev environments for AI coding assistants",
   "type": "module",
   "bin": {

package/src/core/commands/dev.ts

@@ -5,10 +5,10 @@
 // =========================================================================================================================================
 
 import { spawnSync } from "node:child_process";
-import { existsSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
-import { cancel, isCancel, log, multiselect, outro, select } from "@clack/prompts";
+import { cancel, groupMultiselect, isCancel, log, multiselect, outro, path, select } from "@clack/prompts";
 
 // biome-ignore lint/style/noNonNullAssertion: guarded immediately below; non-null assertion needed for closure type inference
 const workspaceDir = process.env.TOTOPO_REPO_ROOT!;
@@ -66,11 +66,60 @@ async function promptScope(): Promise<ScopeConfig> {
 }
 
 // ─── Prompt: selective path selection ─────────────────────────────────────────
+// Recursively expands a selected path into its children when a nested exclusion target is found,
+// until the excluded path itself can be dropped from the list.
+function expandExclusion(paths: string[], excl: string): string[] {
+    if (paths.includes(excl)) {
+        return paths.filter((p) => p !== excl);
+    }
+    const ancestor = paths.find((p) => excl.startsWith(`${p}/`));
+    if (!ancestor) {
+        log.warn(`Cannot exclude "${excl}" — it is not within any selected path. Skipping.`);
+        return paths;
+    }
+    const children = readdirSync(join(cwd, ancestor)).map((child) => `${ancestor}/${child}`);
+    const withoutAncestor = paths.filter((p) => p !== ancestor);
+    return expandExclusion([...withoutAncestor, ...children], excl);
+}
+
+function scanCwdDepth2(): { dirs: Record<string, string[]>; files: string[] } {
+    const dirs: Record<string, string[]> = {};
+    const files: string[] = [];
+
+    for (const item of readdirSync(cwd)) {
+        const itemPath = join(cwd, item);
+        if (statSync(itemPath).isDirectory()) {
+            const children = readdirSync(itemPath).map((child) => `${item}/${child}`);
+            if (children.length === 0) {
+                files.push(item); // empty dir → treat as flat item
+            } else {
+                dirs[item] = children;
+            }
+        } else {
+            files.push(item);
+        }
+    }
+
+    return { dirs, files };
+}
+
+function normalizeSelection(selected: string[], dirNames: string[]): string[] {
+    const withoutGroupKey = selected.filter((s) => s !== "Files");
+    const dirSet = new Set(dirNames);
+
+    return withoutGroupKey.filter((s) => {
+        const slashIdx = s.indexOf("/");
+        if (slashIdx === -1) return true; // depth-1 item, always keep
+        const parent = s.slice(0, slashIdx);
+        return !(dirSet.has(parent) && withoutGroupKey.includes(parent));
+    });
+}
+
 async function promptSelectivePaths(): Promise<string[]> {
-    const allItems = readdirSync(cwd).filter((f) => !f.startsWith("."));
+    const allItems = readdirSync(cwd);
 
     if (allItems.length === 0) {
-        log.warn("No visible files/folders in current directory — falling back to cwd mode.");
+        log.warn("No files/folders in current directory — falling back to cwd mode.");
         return [];
     }
 
@@ -88,21 +137,105 @@ async function promptSelectivePaths(): Promise<string[]> {
     }
 
     const style = styleChoice as "only" | "except";
-    const initialValues = style === "except" ? allItems : [];
+    const { dirs, files } = scanCwdDepth2();
+    const dirNames = Object.keys(dirs);
+
+    if (style === "only") {
+        log.info(
+            "Tip: check a folder header to include everything inside it, or expand it to pick specific files. Use the next step for paths deeper than what's shown.",
+        );
+    } else {
+        log.info(
+            "Tip: everything is selected at the folder level — uncheck a folder header to exclude it entirely, or expand it to exclude specific files. Use the next step for deeper paths.",
+        );
+    }
 
-    const selected = await multiselect({
+    // ── flat fallback when there are no dirs ──────────────────────────────────
+    if (dirNames.length === 0) {
+        const flatSelected = await multiselect({
+            message: "Choose paths:",
+            options: files.map((f) => ({ value: f, label: f })),
+            initialValues: style === "except" ? files : [],
+            required: true,
+        });
+
+        if (isCancel(flatSelected)) {
+            cancel("Cancelled.");
+            process.exit(0);
+        }
+
+        return flatSelected as string[];
+    }
+
+    // ── build groupMultiselect options ────────────────────────────────────────
+    const groupOptions: Record<string, { value: string; label: string }[]> = {};
+    for (const [dir, children] of Object.entries(dirs)) {
+        groupOptions[dir] = children.map((child) => ({
+            value: child,
+            label: child.slice(child.indexOf("/") + 1),
+        }));
+    }
+    if (files.length > 0) {
+        groupOptions.Files = files.map((f) => ({ value: f, label: f }));
+    }
+
+    // "except" → pre-select dir headers + root files (depth-1 only)
+    const initialValues = style === "except" ? [...dirNames, ...files] : [];
+
+    const rawSelected = await groupMultiselect({
         message: "Choose paths:",
-        options: allItems.map((item) => ({ value: item, label: item })),
+        options: groupOptions,
         initialValues,
         required: true,
+        selectableGroups: true,
     });
 
-    if (isCancel(selected)) {
+    if (isCancel(rawSelected)) {
         cancel("Cancelled.");
         process.exit(0);
     }
 
-    return selected as string[];
+    const selected = normalizeSelection(rawSelected as string[], dirNames);
+
+    // ── path prompt loop for depth-3+ targets ────────────────────────────────
+    // Repeats until the user presses Enter on an empty input.
+    let result = selected;
+    const promptMsg =
+        style === "only" ? "Add a deeper path to include (press Enter to finish):" : "Exclude a deeper path (press Enter to finish):";
+
+    while (true) {
+        const deepPathRaw = await path({
+            message: promptMsg,
+            root: cwd,
+            validate: (value) => {
+                if (!value) return undefined; // empty = done, always valid
+                const relative = value.startsWith(`${cwd}/`) ? value.slice(cwd.length + 1) : value;
+                if (!relative) return "Path cannot be empty.";
+                if (!existsSync(join(cwd, relative))) return `Path not found: ${relative}`;
+                return undefined;
+            },
+        });
+
+        if (isCancel(deepPathRaw)) {
+            cancel("Cancelled.");
+            process.exit(0);
+        }
+
+        const deepPathAbsolute = deepPathRaw as string;
+        if (!deepPathAbsolute) break; // user skipped — done
+
+        const deepPath = deepPathAbsolute.startsWith(`${cwd}/`) ? deepPathAbsolute.slice(cwd.length + 1) : deepPathAbsolute;
+
+        if (!deepPath) break;
+
+        if (style === "only") {
+            result = [...new Set([...result, deepPath])];
+        } else {
+            result = expandExclusion(result, deepPath);
+        }
+    }
+
+    return result;
 }
 
 // ─── Totopo mount path inside container ──────────────────────────────────────