dlab-cli 0.1.1__tar.gz → 0.1.3__tar.gz

{dlab_cli-0.1.1 → dlab_cli-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dlab-cli
-Version: 0.1.1
+Version: 0.1.3
 Summary: A harness for agentic data science — run coding agents with domain skills, parallel subagents, and frozen Docker environments
 Author: DecisionAI
 License: Apache-2.0

{dlab_cli-0.1.1 → dlab_cli-0.1.3}/dlab/__init__.py

@@ -3,4 +3,4 @@ dlab: CLI wrapper that runs opencode in automated mode, sandboxed with Docker,
 and with parallel-agent capability.
 """
 
-__version__ = "0.1.1"
+__version__ = "0.1.3"

{dlab_cli-0.1.1 → dlab_cli-0.1.3}/dlab/cli.py

@@ -401,13 +401,18 @@ def cmd_run(args: argparse.Namespace) -> int:
     if continue_mode:
         continue_dir = Path(args.continue_dir).resolve()
         if not continue_dir.exists():
-            raise ValueError(f"Continue directory not found: {args.continue_dir}")
+            console.print(f"Oops, continue directory [bold]{args.continue_dir}[/bold] not found.")
+            return 1
 
         if args.work_dir:
             # Copy continue-dir to work-dir, then continue from there
             work_path = Path(args.work_dir).resolve()
             if work_path.exists():
-                raise ValueError(f"Work directory already exists: {args.work_dir}")
+                console.print(
+                    f"Oops, work directory [bold]{args.work_dir}[/bold] already exists.\n"
+                    f"You can remove it with: [cyan]rm -rf {args.work_dir}[/cyan]"
+                )
+                return 1
             shutil.copytree(continue_dir, work_path)
             work_dir = str(work_path)
             print(f"Copied {continue_dir} to {work_dir}")
@@ -423,10 +428,9 @@ def cmd_run(args: argparse.Namespace) -> int:
         # Overwrite .opencode with latest from decision-pack (agent prompts may have changed)
         opencode_dir = Path(work_dir) / ".opencode"
         if opencode_dir.exists():
-            if no_sandboxing:
-                # Local mode: files are user-owned
+            try:
                 shutil.rmtree(opencode_dir)
-            else:
+            except PermissionError:
                 # Docker mode: files may be root-owned (e.g. node_modules/)
                 subprocess.run(
                     ["sudo", "rm", "-rf", str(opencode_dir)],

{dlab_cli-0.1.1 → dlab_cli-0.1.3}/dlab/create_dpack.py

@@ -884,8 +884,16 @@ export default tool({
   args: {
     input: tool.schema.string().describe("Input to process"),
   },
-  async run({ input }) {
-    return `Processed: ${input}`
+  async execute(args) {
+    // Run a CLI command with Bun shell (e.g. Python, bash, etc.)
+    const result = await Bun.$`echo "Processing: ${args.input}"`.nothrow()
+    const stdout = result.stdout.toString()
+    const stderr = result.stderr.toString()
+
+    if (result.exitCode !== 0) {
+      return `ERROR (exit code ${result.exitCode}):\\n${stderr}`
+    }
+    return stdout.trim()
   },
 })
 """

{dlab_cli-0.1.1 → dlab_cli-0.1.3}/dlab/docker.py

@@ -243,13 +243,14 @@ def _run_docker_build(
         stderr=subprocess.STDOUT,
         text=True,
     )
-    stderr_lines: list[str] = []
+    output_lines: list[str] = []
     for line in proc.stdout:  # type: ignore[union-attr]
         line = line.rstrip("\n")
+        output_lines.append(line)
         if on_output:
             on_output(line)
     proc.wait()
-    return proc.returncode, "\n".join(stderr_lines)
+    return proc.returncode, "\n".join(output_lines)
 
 
 def build_image(

{dlab_cli-0.1.1 → dlab_cli-0.1.3}/dlab/js/parallel-agents.ts

@@ -1,6 +1,7 @@
 import { tool } from "@opencode-ai/plugin"
 import { readFileSync, mkdirSync, writeFileSync, existsSync, appendFileSync, readdirSync, copyFileSync, cpSync, statSync } from "fs"
-import { parse as parseYaml } from "yaml"
+// Use require() for CJS package — ESM imports break under Bun's strict interop
+const yaml = require("yaml")
 import { join, basename } from "path"
 
 // Helper: Copy directory contents excluding certain paths
@@ -24,7 +25,7 @@ function parseAgentFrontmatter(agentPath: string): Record<string, any> {
   const content = readFileSync(agentPath, "utf-8")
   const match = content.match(/^---\n([\s\S]*?)\n---/)
   if (!match) return {}
-  return parseYaml(match[1])
+  return yaml.parse(match[1])
 }
 
 // Helper: Build permission config from agent frontmatter tools
@@ -192,7 +193,7 @@ export default tool({
     if (!existsSync(configPath)) {
       throw new Error(`No parallel config found: ${configPath}`)
     }
-    const config = parseYaml(readFileSync(configPath, "utf-8"))
+    const config = yaml.parse(readFileSync(configPath, "utf-8"))
 
     // Validate instance count
     const numInstances = args.prompts.length

{dlab_cli-0.1.1 → dlab_cli-0.1.3}/dlab_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dlab-cli
-Version: 0.1.1
+Version: 0.1.3
 Summary: A harness for agentic data science — run coding agents with domain skills, parallel subagents, and frozen Docker environments
 Author: DecisionAI
 License: Apache-2.0

{dlab_cli-0.1.1 → dlab_cli-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dlab-cli"
-version = "0.1.1"
+version = "0.1.3"
 description = "A harness for agentic data science — run coding agents with domain skills, parallel subagents, and frozen Docker environments"
 readme = "README.md"
 requires-python = ">=3.11"

{dlab_cli-0.1.1 → dlab_cli-0.1.3}/tests/test_cli.py

@@ -408,6 +408,195 @@ class TestErrorMessages:
         assert "rm -rf" in captured.out
 
 
+class TestContinueDir:
+    """Tests for --continue-dir functionality in both Docker and local modes."""
+
+    @pytest.fixture
+    def previous_session(
+        self, dpack_config_dir: Path, data_dir: Path, tmp_path: Path,
+    ) -> Path:
+        """Create a completed session to continue from."""
+        from dlab.config import load_dpack_config
+        from dlab.session import create_session
+
+        config: dict[str, Any] = load_dpack_config(str(dpack_config_dir))
+        state: dict[str, Any] = create_session(
+            config, str(data_dir), work_dir=str(tmp_path / "prev-session"),
+        )
+        return Path(state["work_dir"])
+
+    def _run_continue(
+        self,
+        dpack_dir: Path,
+        continue_dir: Path,
+        work_dir: Path | None = None,
+        prompt: str = "continue",
+        no_sandboxing: bool = False,
+        extra_args: list[str] | None = None,
+    ) -> int:
+        """Helper to run cmd_run in continue mode, mocking agent execution."""
+        parser = create_parser()
+        cmd: list[str] = [
+            "--dpack", str(dpack_dir),
+            "--continue-dir", str(continue_dir),
+            "--prompt", prompt,
+        ]
+        if work_dir:
+            cmd.extend(["--work-dir", str(work_dir)])
+        if no_sandboxing:
+            cmd.append("--no-sandboxing")
+        if extra_args:
+            cmd.extend(extra_args)
+        args = parser.parse_args(cmd)
+
+        # Mock agent execution so tests don't hang on real LLM calls
+        mock_return = (0, "", "")
+        with patch("dlab.cli.run_opencode", return_value=mock_return), \
+             patch("dlab.local.run_opencode_local", return_value=mock_return):
+            return cmd_run(args)
+
+    # --- Error handling (no mode needed, errors before execution) ---
+
+    def test_continue_nonexistent_dir(
+        self, dpack_config_dir: Path, capsys: pytest.CaptureFixture[str],
+    ) -> None:
+        """Should error cleanly when continue-dir doesn't exist."""
+        result: int = self._run_continue(
+            dpack_config_dir, Path("/nonexistent/dir"),
+        )
+        assert result == 1
+        captured = capsys.readouterr()
+        assert "not found" in captured.out
+
+    def test_continue_with_data_rejected(
+        self, dpack_config_dir: Path, data_dir: Path, previous_session: Path,
+        capsys: pytest.CaptureFixture[str],
+    ) -> None:
+        """Should reject --data combined with --continue-dir."""
+        parser = create_parser()
+        args = parser.parse_args([
+            "--dpack", str(dpack_config_dir),
+            "--continue-dir", str(previous_session),
+            "--data", str(data_dir),
+            "--prompt", "continue",
+        ])
+        result: int = cmd_run(args)
+        assert result == 1
+
+    def test_continue_workdir_exists_error(
+        self, dpack_config_dir: Path, previous_session: Path, tmp_path: Path,
+        capsys: pytest.CaptureFixture[str],
+    ) -> None:
+        """Should error when --work-dir already exists in continue mode."""
+        existing: Path = tmp_path / "already-here"
+        existing.mkdir()
+        result: int = self._run_continue(
+            dpack_config_dir, previous_session,
+            work_dir=existing, no_sandboxing=True,
+        )
+        assert result == 1
+        captured = capsys.readouterr()
+        assert "already exists" in captured.out
+
+    # --- Local mode (--no-sandboxing) ---
+
+    def test_local_continue_to_new_workdir(
+        self, dpack_config_dir: Path, previous_session: Path, tmp_path: Path,
+    ) -> None:
+        """Local: --continue-dir + --work-dir should copy session."""
+        new_dir: Path = tmp_path / "local-continued"
+        self._run_continue(
+            dpack_config_dir, previous_session,
+            work_dir=new_dir, no_sandboxing=True,
+        )
+        assert new_dir.exists()
+        assert (new_dir / "data").exists()
+        assert (new_dir / ".opencode").exists()
+        assert (new_dir / "_opencode_logs").exists()
+
+    def test_local_continue_refreshes_opencode(
+        self, dpack_config_dir: Path, previous_session: Path, tmp_path: Path,
+    ) -> None:
+        """Local: continue should refresh .opencode/ from decision-pack."""
+        new_dir: Path = tmp_path / "local-refreshed"
+        marker: Path = previous_session / ".opencode" / "STALE_MARKER"
+        marker.write_text("this should be gone after continue")
+
+        self._run_continue(
+            dpack_config_dir, previous_session,
+            work_dir=new_dir, no_sandboxing=True,
+        )
+        assert not (new_dir / ".opencode" / "STALE_MARKER").exists()
+        assert (new_dir / ".opencode").exists()
+
+    def test_local_continue_refreshes_hooks(
+        self, dpack_config_dir: Path, previous_session: Path, tmp_path: Path,
+    ) -> None:
+        """Local: continue should refresh hook scripts."""
+        new_dir: Path = tmp_path / "local-hooks"
+        hooks_dir: Path = previous_session / "_hooks"
+        hooks_dir.mkdir(exist_ok=True)
+        (hooks_dir / "old_hook.sh").write_text("stale")
+
+        self._run_continue(
+            dpack_config_dir, previous_session,
+            work_dir=new_dir, no_sandboxing=True,
+        )
+        assert not (new_dir / "_hooks" / "old_hook.sh").exists()
+
+    def test_local_continue_preserves_data(
+        self, dpack_config_dir: Path, previous_session: Path, tmp_path: Path,
+    ) -> None:
+        """Local: continue should preserve data from original session."""
+        new_dir: Path = tmp_path / "local-preserved"
+        self._run_continue(
+            dpack_config_dir, previous_session,
+            work_dir=new_dir, no_sandboxing=True,
+        )
+        assert (new_dir / "data" / "sample.csv").exists()
+        assert (new_dir / "data" / "subdir" / "nested.txt").exists()
+
+    # --- Docker mode ---
+
+    def test_docker_continue_to_new_workdir(
+        self, dpack_config_dir: Path, previous_session: Path, tmp_path: Path,
+    ) -> None:
+        """Docker: --continue-dir + --work-dir should copy session."""
+        new_dir: Path = tmp_path / "docker-continued"
+        self._run_continue(
+            dpack_config_dir, previous_session, work_dir=new_dir,
+        )
+        assert new_dir.exists()
+        assert (new_dir / "data").exists()
+        assert (new_dir / ".opencode").exists()
+        assert (new_dir / "_opencode_logs").exists()
+
+    def test_docker_continue_refreshes_opencode(
+        self, dpack_config_dir: Path, previous_session: Path, tmp_path: Path,
+    ) -> None:
+        """Docker: continue should refresh .opencode/ from decision-pack."""
+        new_dir: Path = tmp_path / "docker-refreshed"
+        marker: Path = previous_session / ".opencode" / "STALE_MARKER"
+        marker.write_text("this should be gone after continue")
+
+        self._run_continue(
+            dpack_config_dir, previous_session, work_dir=new_dir,
+        )
+        assert not (new_dir / ".opencode" / "STALE_MARKER").exists()
+        assert (new_dir / ".opencode").exists()
+
+    def test_docker_continue_preserves_data(
+        self, dpack_config_dir: Path, previous_session: Path, tmp_path: Path,
+    ) -> None:
+        """Docker: continue should preserve data from original session."""
+        new_dir: Path = tmp_path / "docker-preserved"
+        self._run_continue(
+            dpack_config_dir, previous_session, work_dir=new_dir,
+        )
+        assert (new_dir / "data" / "sample.csv").exists()
+        assert (new_dir / "data" / "subdir" / "nested.txt").exists()
+
+
 class TestCmdInstall:
     """Tests for cmd_install function."""
 

{dlab_cli-0.1.1 → dlab_cli-0.1.3}/tests/test_create_dpack.py

@@ -10,6 +10,8 @@ import pytest
 import yaml
 
 from dlab.create_dpack import (
+    EXAMPLE_TOOL_TS,
+    RUN_ON_MODAL_TS,
     filter_models,
     generate_dpack,
     validate_dpack_name,
@@ -431,6 +433,46 @@ class TestSkeletonTools:
         assert "exitCode" in content
 
 
+class TestToolTemplatesApi:
+    """Tests that tool templates use the correct OpenCode API."""
+
+    def test_example_tool_uses_execute_not_run(self) -> None:
+        """example-tool.ts MUST use execute(), not run().
+
+        OpenCode calls def.execute(args, ctx) on custom tools.
+        Using run() causes 'def.execute is not a function' at runtime.
+        """
+        assert "async execute(" in EXAMPLE_TOOL_TS, (
+            "EXAMPLE_TOOL_TS must use 'async execute(args)' — "
+            "OpenCode calls def.execute(), not def.run()"
+        )
+        assert "async run(" not in EXAMPLE_TOOL_TS, (
+            "EXAMPLE_TOOL_TS must NOT use 'async run()' — "
+            "this causes 'def.execute is not a function' at runtime"
+        )
+
+    def test_modal_tool_uses_execute_not_run(self) -> None:
+        """run-on-modal.ts MUST use execute(), not run()."""
+        assert "async execute(" in RUN_ON_MODAL_TS
+        assert "async run(" not in RUN_ON_MODAL_TS
+
+    def test_example_tool_uses_bun_shell(self) -> None:
+        """example-tool.ts should demonstrate Bun shell for CLI commands."""
+        assert "Bun.$" in EXAMPLE_TOOL_TS, (
+            "EXAMPLE_TOOL_TS should use Bun.$`...` for CLI commands"
+        )
+        assert ".nothrow()" in EXAMPLE_TOOL_TS, (
+            "EXAMPLE_TOOL_TS should use .nothrow() for error handling"
+        )
+
+    def test_generated_tool_uses_execute(self, tmp_path: Path) -> None:
+        """Generated example-tool.ts must use execute(), not run()."""
+        generate_dpack(tmp_path, {"name": "api-test", "skeletons": {"tools": True}})
+        content: str = (tmp_path / "api-test" / "opencode" / "tools" / "example-tool.ts").read_text()
+        assert "async execute(" in content
+        assert "async run(" not in content
+
+
 class TestSkeletonSkills:
     """Tests for skills skeleton."""
 

{dlab_cli-0.1.1 → dlab_cli-0.1.3}/tests/test_docker.py

@@ -10,6 +10,7 @@ from typing import Any
 import pytest
 
 from dlab.docker import (
+    _run_docker_build,
     build_image,
     build_runner_script,
     compute_docker_dir_hash,
@@ -103,6 +104,18 @@ class TestBuildImage:
         with pytest.raises(ValueError, match="Docker build failed"):
             build_image(str(tmp_path), "test-image")
 
+    def test_build_error_includes_output(self, tmp_path: Path) -> None:
+        """Build failures should include diagnostic output, not an empty string."""
+        docker_path: Path = tmp_path / "docker"
+        docker_path.mkdir()
+        (docker_path / "Dockerfile").write_text("FROM nonexistent-image-xxxxx\n")
+
+        returncode, output = _run_docker_build(
+            ["docker", "build", str(docker_path)],
+        )
+        assert returncode != 0
+        assert len(output) > 0, "Build error output should not be empty"
+
 
 class TestContainerExists:
     """Tests for container_exists function."""

{dlab_cli-0.1.1 → dlab_cli-0.1.3}/tests/test_integration.py

@@ -49,6 +49,15 @@ def _has_api_key() -> bool:
     return "ANTHROPIC_API_KEY=" in content
 
 
+def _has_google_key() -> bool:
+    """Check if .env file exists and contains a Google AI API key."""
+    env_path: Path = Path(ENV_FILE)
+    if not env_path.exists():
+        return False
+    content: str = env_path.read_text()
+    return "GOOGLE_GENERATIVE_AI_API_KEY=" in content
+
+
 def _remove_image(name: str) -> None:
     """Remove a Docker image, ignoring errors if it doesn't exist."""
     subprocess.run(["docker", "rmi", "-f", name], capture_output=True)
@@ -386,3 +395,70 @@ class TestEndToEnd:
         assert (work_dir / "final_poem.md").exists()
         poem_content: str = (work_dir / "final_poem.md").read_text()
         assert len(poem_content.strip()) > 0
+
+
+# ---------------------------------------------------------------------------
+# TestOpenCodeLatest
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.skipif(not _has_google_key(), reason="No GOOGLE_GENERATIVE_AI_API_KEY in .env")
+class TestOpenCodeLatest:
+    """
+    End-to-end test with opencode latest (no pinned version).
+
+    Uses the poem decision-pack with google/gemini-2.5-flash to verify
+    that parallel-agents.ts works with the latest opencode release.
+    This catches ESM/CJS interop regressions (issue #17).
+
+    Requires GOOGLE_GENERATIVE_AI_API_KEY in the .env file at repo root.
+    """
+
+    LATEST_IMAGE_NAME: str = "dlab-opencode-latest-test"
+
+    @pytest.fixture(scope="class")
+    def latest_dpack_dir(self, tmp_path_factory: pytest.TempPathFactory) -> Path:
+        """Copy poem dpack with opencode_version removed (forces latest)."""
+        base: Path = tmp_path_factory.mktemp("latest_dpack")
+        dpack_copy: Path = base / "poem"
+        shutil.copytree(POEM_DPACK_DIR, str(dpack_copy))
+
+        config_path: Path = dpack_copy / "config.yaml"
+        config_data: dict[str, Any] = yaml.safe_load(config_path.read_text())
+        config_data.pop("opencode_version", None)
+        config_data["docker_image_name"] = self.LATEST_IMAGE_NAME
+        config_path.write_text(yaml.dump(config_data))
+
+        return dpack_copy
+
+    @pytest.fixture(scope="class", autouse=True)
+    def cleanup_image(self) -> Generator[None, None, None]:
+        yield
+        _remove_image(self.LATEST_IMAGE_NAME)
+        _remove_image(f"{self.LATEST_IMAGE_NAME}-base")
+
+    def test_poem_with_opencode_latest(
+        self, latest_dpack_dir: Path, tmp_path: Path,
+    ) -> None:
+        """Full poem run with opencode latest — catches yaml import issues."""
+        work_dir: Path = tmp_path / "latest-test"
+
+        parser: argparse.ArgumentParser = create_parser()
+        args: argparse.Namespace = parser.parse_args([
+            "--dpack", str(latest_dpack_dir),
+            "--prompt", "Write a haiku about the sea.",
+            "--work-dir", str(work_dir),
+            "--env-file", ENV_FILE,
+        ])
+
+        exit_code: int = cmd_run(args)
+
+        assert exit_code == 0, (
+            f"Poem run with opencode latest failed (exit {exit_code}). "
+            f"Check {work_dir / '_opencode_logs'} for details."
+        )
+
+        # Agent ran and produced a log
+        main_log: Path = work_dir / "_opencode_logs" / "main.log"
+        assert main_log.exists()
+        assert main_log.stat().st_size > 0

dlab_cli-0.1.3/tests/test_parallel_tool.py

@@ -0,0 +1,149 @@
+"""
+Tests for dlab.parallel_tool module.
+"""
+
+import json
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from dlab.parallel_tool import PARALLEL_AGENTS_SOURCE
+
+# Node built-in modules and OpenCode packages are safe for ESM named imports
+_ALLOWED_ESM_NAMED_IMPORTS: set[str] = {
+    "fs", "path", "os", "util", "url", "child_process", "crypto",
+    "stream", "events", "http", "https", "net", "assert",
+    "@opencode-ai/plugin",
+}
+
+
+class TestParallelAgentsSource:
+    """Tests for PARALLEL_AGENTS_SOURCE loading."""
+
+    def test_loads_successfully(self) -> None:
+        """PARALLEL_AGENTS_SOURCE should be a non-empty string."""
+        assert isinstance(PARALLEL_AGENTS_SOURCE, str)
+        assert len(PARALLEL_AGENTS_SOURCE) > 0
+
+    def test_contains_tool_export(self) -> None:
+        """Should contain the tool description marker."""
+        assert "Spawn parallel subagents" in PARALLEL_AGENTS_SOURCE
+
+    def test_contains_key_functions(self) -> None:
+        """Should contain key TypeScript functions from the source."""
+        assert "copyWorkDir" in PARALLEL_AGENTS_SOURCE
+        assert "setupConsolidator" in PARALLEL_AGENTS_SOURCE
+        assert "buildPermissionsFromFrontmatter" in PARALLEL_AGENTS_SOURCE
+
+    def test_matches_source_file(self) -> None:
+        """Content should match the .ts file read directly from disk."""
+        source_file: Path = Path(__file__).parent.parent / "dlab" / "js" / "parallel-agents.ts"
+        expected: str = source_file.read_text()
+        assert PARALLEL_AGENTS_SOURCE == expected
+
+    def test_no_esm_named_imports_from_third_party(self) -> None:
+        """Third-party packages must use default imports to avoid CJS/ESM issues.
+
+        ESM named imports (import { x } from "pkg") break when the package
+        is CommonJS. Node built-ins and @opencode-ai/* are safe.
+        """
+        pattern: re.Pattern[str] = re.compile(
+            r'import\s*\{[^}]+\}\s*from\s*["\']([^"\']+)["\']'
+        )
+        for match in pattern.finditer(PARALLEL_AGENTS_SOURCE):
+            pkg: str = match.group(1)
+            assert pkg in _ALLOWED_ESM_NAMED_IMPORTS, (
+                f"ESM named import from third-party package '{pkg}' — "
+                f"use default import instead (import pkg from \"{pkg}\") "
+                f"to avoid CJS/ESM interop issues"
+            )
+
+
+class TestYamlImportRuntime:
+    """Verify that the yaml import in parallel-agents.ts works at runtime.
+
+    Catches ESM/CJS interop issues that static analysis alone would miss.
+    """
+
+    @pytest.fixture
+    def js_workspace(self, tmp_path: Path) -> Path:
+        """Set up a temp workspace with yaml installed, mirroring session setup."""
+        pkg: dict[str, object] = {"dependencies": {"yaml": "^2.0.0"}}
+        (tmp_path / "package.json").write_text(json.dumps(pkg))
+        result: subprocess.CompletedProcess[str] = subprocess.run(
+            ["npm", "install", "--silent"],
+            cwd=tmp_path,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        if result.returncode != 0:
+            pytest.skip(f"npm install failed: {result.stderr}")
+        return tmp_path
+
+    def test_yaml_import_node(self, js_workspace: Path) -> None:
+        """yaml import must resolve and parse() must work under Node."""
+        # Extract just the yaml import line from our source
+        import_lines: list[str] = [
+            line for line in PARALLEL_AGENTS_SOURCE.splitlines()
+            if "yaml" in line and ("import" in line or "require" in line)
+        ]
+        assert import_lines, "No yaml import found in parallel-agents.ts"
+
+        # Build a minimal JS test that does what our .ts does
+        test_js: str = (
+            'const yaml = require("yaml");\n'
+            'const result = yaml.parse("key: value");\n'
+            'if (result.key !== "value") { process.exit(1); }\n'
+            'console.log("ok");\n'
+        )
+        test_file: Path = js_workspace / "test_yaml.js"
+        test_file.write_text(test_js)
+
+        result: subprocess.CompletedProcess[str] = subprocess.run(
+            ["node", str(test_file)],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        assert result.returncode == 0, (
+            f"yaml require() failed under Node:\n"
+            f"stdout: {result.stdout}\nstderr: {result.stderr}"
+        )
+
+    def test_yaml_import_docker(self, js_workspace: Path) -> None:
+        """yaml import must work inside a Docker container (closer to production)."""
+        test_js: str = (
+            'const yaml = require("yaml");\n'
+            'const result = yaml.parse("key: value");\n'
+            'if (result.key !== "value") { process.exit(1); }\n'
+            'console.log("ok");\n'
+        )
+        test_file: Path = js_workspace / "test_yaml.js"
+        test_file.write_text(test_js)
+
+        result: subprocess.CompletedProcess[str] = subprocess.run(
+            [
+                "docker", "run", "--rm",
+                "-v", f"{js_workspace}:/app",
+                "-w", "/app",
+                "node:20-slim",
+                "node", "test_yaml.js",
+            ],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        assert result.returncode == 0, (
+            f"yaml require() failed inside Docker (node:20-slim):\n"
+            f"stdout: {result.stdout}\nstderr: {result.stderr}"
+        )
+
+    def test_import_style_matches_source(self) -> None:
+        """The yaml import in parallel-agents.ts must use require(), not ESM import."""
+        assert 'require("yaml")' in PARALLEL_AGENTS_SOURCE, (
+            "parallel-agents.ts must use require('yaml') for CJS/ESM compatibility"
+        )

dlab_cli-0.1.1/tests/test_parallel_tool.py

@@ -1,32 +0,0 @@
-"""
-Tests for dlab.parallel_tool module.
-"""
-
-from pathlib import Path
-
-from dlab.parallel_tool import PARALLEL_AGENTS_SOURCE
-
-
-class TestParallelAgentsSource:
-    """Tests for PARALLEL_AGENTS_SOURCE loading."""
-
-    def test_loads_successfully(self) -> None:
-        """PARALLEL_AGENTS_SOURCE should be a non-empty string."""
-        assert isinstance(PARALLEL_AGENTS_SOURCE, str)
-        assert len(PARALLEL_AGENTS_SOURCE) > 0
-
-    def test_contains_tool_export(self) -> None:
-        """Should contain the tool description marker."""
-        assert "Spawn parallel subagents" in PARALLEL_AGENTS_SOURCE
-
-    def test_contains_key_functions(self) -> None:
-        """Should contain key TypeScript functions from the source."""
-        assert "copyWorkDir" in PARALLEL_AGENTS_SOURCE
-        assert "setupConsolidator" in PARALLEL_AGENTS_SOURCE
-        assert "buildPermissionsFromFrontmatter" in PARALLEL_AGENTS_SOURCE
-
-    def test_matches_source_file(self) -> None:
-        """Content should match the .ts file read directly from disk."""
-        source_file: Path = Path(__file__).parent.parent / "dlab" / "js" / "parallel-agents.ts"
-        expected: str = source_file.read_text()
-        assert PARALLEL_AGENTS_SOURCE == expected