@scemoon/cdh 1.0.0

package/pyproject.toml

@@ -0,0 +1,60 @@
+[project]
+name = "cloud-dev-harness"
+version = "1.0.0"
+description = "Cloud Dev Harness - cloud-native development Agent framework with A2TUI"
+requires-python = ">=3.14.2"
+dependencies = [
+    "textual>=0.46.0",
+    "textual[syntax]==8.2.6",
+    "click==8.4.0",
+    "platformdirs==4.9.6",
+    "rich>=13.7.0",
+    "rich==15.0.0",
+    "pydantic>=2.5.0",
+    "pyyaml>=6.0",
+    "click>=8.1.0",
+    "python-dotenv>=1.0.0",
+    "sqlalchemy>=2.0.0",
+    "sqlite-utils>=3.35",
+    "httpx>=0.25.0",
+    "typeguard==4.5.2",
+    "xdg-base-dirs>=6.0.2",
+    "textual-serve>=1.1.2",
+    "textual-speedups==0.2.1",
+    "packaging==26.2",
+    "bashlex==0.18",
+    "pathspec==1.1.1",
+    "notify-py==0.3.43",
+    "pyperclip==1.11.0",
+    "watchdog==6.0.0",
+    "setproctitle==1.3.7",
+    "psutil==7.2.2",
+    "aiosqlite==0.22.1",
+    "textual-diff-view==0.1.5",
+    "typing-extensions==4.15.0",
+]
+
+[project.scripts]
+cdh = "cdh.cli:main"
+onecode-agent-acp = "onecode.agent.onecode_agent_acp:main"
+onecode = "onecode.cli:main"
+tui = "tui.cli:main"
+
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["onecode*", "cdh*", "tui*"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[dependency-groups]
+dev = [
+    "mypy>=1.19.1",
+    "pyinstrument>=5.1.1",
+    "pytest>=9.0.3",
+    "pytest-asyncio>=1.4.0",
+    "textual-dev>=1.8.0",
+]

package/run.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+const { spawn, execSync } = require('child_process');
+const path = require('path');
+
+function exec(cmd, opts = {}) {
+  try {
+    return { ok: true, out: execSync(cmd, { stdio: 'pipe', ...opts }).toString().trim() };
+  } catch (e) {
+    return { ok: false, out: e.stderr?.toString() || e.message };
+  }
+}
+
+function checkPython() {
+  const script = 'import sys; v=sys.version_info; print(f"{v.major}.{v.minor}")';
+  const r = exec(`python3 -c "${script}"`);
+  if (!r.ok) return { ok: false, version: null, pythonCmd: null };
+  const [major, minor] = r.out.split('.').map(Number);
+  return {
+    ok: major > 3 || (major === 3 && minor >= 14),
+    version: `${major}.${minor}`,
+    pythonCmd: 'python3'
+  };
+}
+
+function checkUv() {
+  const r = exec('uv --version');
+  return r.ok;
+}
+
+function checkCdhInstalled(pythonCmd) {
+  return exec(`${pythonCmd} -m pip show cloud-dev-harness 2>/dev/null`).ok;
+}
+
+function run(pythonModule) {
+  const PKG_DIR = __dirname;
+  const PYTHON_ENV_DIR = path.join(require('os').homedir(), '.onecode', 'python');
+
+  const isPostinstall = process.argv.length <= 2;
+  const py = checkPython();
+
+  if (!py.ok) {
+    console.error(`cdh: Python ${py.version || 'not found'}, version 3.14+ is required.`);
+
+    if (checkUv()) {
+      console.log('cdh: Creating Python environment with uv...');
+      exec(`uv venv "${PYTHON_ENV_DIR}"`);
+      const venvPython = path.join(PYTHON_ENV_DIR, 'bin', 'python');
+      console.log('cdh: Installing cloud-dev-harness...');
+      exec(`"${venvPython}" -m pip install -e "${PKG_DIR}"`);
+      if (isPostinstall) {
+        console.log('cdh: Installed. Add to PATH: export PATH="$HOME/.onecode/python/bin:$PATH"');
+        process.exit(0);
+      }
+      spawn(venvPython, ['-m', pythonModule, ...process.argv.slice(2)], { stdio: 'inherit' })
+        .on('exit', process.exit);
+      return;
+    }
+
+    console.error('cdh: Install Python 3.14+ or uv (https://github.com/astral-sh/uv).');
+    process.exit(isPostinstall ? 0 : 1);
+  }
+
+  if (!checkCdhInstalled(py.pythonCmd)) {
+    console.log('cdh: Installing cloud-dev-harness...');
+    exec(`${py.pythonCmd} -m pip install "${PKG_DIR}"`);
+  }
+
+  if (isPostinstall) {
+    console.log('cdh: Installed. Run "cdh" to start.');
+    process.exit(0);
+  }
+
+  const args = process.argv.slice(2).filter(a => !a.startsWith('--'));
+  const cmd = spawn(py.pythonCmd, ['-m', pythonModule, ...args], {
+    stdio: 'inherit',
+    cwd: PKG_DIR,
+  });
+
+  cmd.on('exit', (code) => process.exit(code));
+  cmd.on('error', (err) => {
+    console.error('cdh: Failed to start:', err.message);
+    process.exit(1);
+  });
+}
+
+module.exports = { run };

package/tui/__init__.py

@@ -0,0 +1,46 @@
+from typing import Literal
+import platform
+
+NAME = "tui"
+TITLE = "A2TUI"
+
+OS = Literal["linux", "macos", "windows", "*"]
+
+_system = platform.system()
+_OS_map: dict[str, OS] = {
+    "Linux": "linux",
+    "Darwin": "macos",
+    "Windows": "windows",
+}
+os: OS = _OS_map.get(_system, "linux")
+
+
+def get_os_matrix(matrix: dict[OS, str]) -> str | None:
+    """Get a value from a mapping where the key is an OS, falling back to a wildcard ("*").
+
+    Args:
+        matrix: A mapping where an OS literal is the key.
+
+    Returns:
+        The value, if one is found, or `None`.
+    """
+    if (result := matrix.get(os)) is None:
+        result = matrix.get("*")
+    return result
+
+
+def get_version() -> str:
+    """Get the current version of A2TUI.
+
+    Returns:
+        str: Version string, e.g "1.2.3"
+    """
+    from importlib.metadata import version
+
+    try:
+        return version("batrachian-tui")
+    except Exception:
+        try:
+            return version("tui")
+        except Exception:
+            return "0.1.0unknown"

package/tui/__main__.py

@@ -0,0 +1,4 @@
+from tui.cli import main
+
+if __name__ == "__main__":
+    main()

package/tui/_loop.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from typing import Iterable, Literal, Sequence, TypeVar
+
+T = TypeVar("T")
+
+
+def loop_first(values: Iterable[T]) -> Iterable[tuple[bool, T]]:
+    """Iterate and generate a tuple with a flag for first value."""
+    iter_values = iter(values)
+    try:
+        value = next(iter_values)
+    except StopIteration:
+        return
+    yield True, value
+    for value in iter_values:
+        yield False, value
+
+
+def loop_last(values: Iterable[T]) -> Iterable[tuple[bool, T]]:
+    """Iterate and generate a tuple with a flag for last value."""
+    iter_values = iter(values)
+    try:
+        previous_value = next(iter_values)
+    except StopIteration:
+        return
+    for value in iter_values:
+        yield False, previous_value
+        previous_value = value
+    yield True, previous_value
+
+
+def loop_first_last(values: Iterable[T]) -> Iterable[tuple[bool, bool, T]]:
+    """Iterate and generate a tuple with a flag for first and last value."""
+    iter_values = iter(values)
+    try:
+        previous_value = next(iter_values)
+    except StopIteration:
+        return
+    first = True
+    for value in iter_values:
+        yield first, False, previous_value
+        first = False
+        previous_value = value
+    yield first, True, previous_value
+
+
+def loop_from_index(
+    values: Sequence[T],
+    index: int,
+    direction: Literal[-1, +1] = +1,
+    wrap: bool = True,
+) -> Iterable[tuple[int, T]]:
+    """Iterate over values in a sequence from a given starting index, potentially wrapping the index
+    if it would go out of bounds.
+
+    Note that the first value to be yielded is a step from `index`, and `index` will be yielded *last*.
+
+
+    Args:
+        values: A sequence of values.
+        index: Starting index.
+        direction: Direction to move index (+1 for forward, -1 for backward).
+        bool: Should the index wrap when out of bounds?
+
+    Yields:
+        A tuple of index and value from the sequence.
+    """
+    # Sanity check for devs who miss the typing errors
+    assert direction in (-1, +1), "direction must be -1 or +1"
+    count = len(values)
+    if wrap:
+        for _ in range(count):
+            index = (index + direction) % count
+            yield (index, values[index])
+    else:
+        if direction == +1:
+            for _ in range(count):
+                if (index := index + 1) >= count:
+                    break
+                yield (index, values[index])
+        else:
+            for _ in range(count):
+                if (index := index - 1) < 0:
+                    break
+                yield (index, values[index])

package/tui/_path_fuzzy_search.py

@@ -0,0 +1,48 @@
+from functools import lru_cache
+from typing import Sequence
+import re
+
+
+from tui.fuzzy import FuzzySearch
+
+
+class PathFuzzySearch(FuzzySearch):
+    @classmethod
+    @lru_cache(maxsize=1024)
+    def get_first_letters(cls, candidate: str) -> frozenset[int]:
+        return frozenset(
+            {
+                0,
+                *[match.start() + 1 for match in re.finditer(r"/", candidate)],
+            }
+        )
+
+    def score(self, candidate: str, positions: Sequence[int]) -> float:
+        """Score a search.
+
+        Args:
+            search: Search object.
+
+        Returns:
+            Score.
+        """
+        first_letters = self.get_first_letters(candidate)
+        # This is a heuristic, and can be tweaked for better results
+        # Boost first letter matches
+        offset_count = len(positions)
+        score: float = offset_count + len(first_letters.intersection(positions))
+
+        groups = 1
+        last_offset, *offsets = positions
+        for offset in offsets:
+            if offset != last_offset + 1:
+                groups += 1
+            last_offset = offset
+
+        # Boost to favor less groups
+        normalized_groups = (offset_count - (groups - 1)) / offset_count
+        score *= 1 + (normalized_groups * normalized_groups)
+
+        if positions[0] > candidate.rfind("/"):
+            score *= 2
+        return score

package/tui/_path_match.py

@@ -0,0 +1,141 @@
+from functools import lru_cache
+from operator import itemgetter
+import re
+from typing import Iterable, Sequence
+
+
+class PathFuzzySearch:
+    """Performs a fuzzy search.
+
+    Unlike a regex solution, this will finds all possible matches.
+    """
+
+    def __init__(
+        self, case_sensitive: bool = False, *, cache_size: int = 1024 * 4
+    ) -> None:
+        """Initialize fuzzy search.
+
+        Args:
+            case_sensitive: Is the match case sensitive?
+            cache_size: Number of queries to cache.
+        """
+
+        self.case_sensitive = case_sensitive
+
+    def match(self, query: str, candidate: str) -> tuple[float, Sequence[int]]:
+        """Match against a query.
+
+        Args:
+            query: The fuzzy query.
+            candidate: A candidate to check,.
+
+        Returns:
+            A pair of (score, tuple of offsets). `(0, ())` for no result.
+        """
+        default: tuple[float, Sequence[int]] = (0.0, [])
+        result = max(self._match(query, candidate), key=itemgetter(0), default=default)
+        return result
+
+    @classmethod
+    @lru_cache(maxsize=1024)
+    def get_first_letters(cls, candidate: str) -> frozenset[int]:
+        return frozenset(
+            {
+                0,
+                *[match.start() + 1 for match in re.finditer(r"/", candidate)],
+            }
+        )
+
+    def score(self, candidate: str, positions: Sequence[int]) -> float:
+        """Score a search.
+
+        Args:
+            search: Search object.
+
+        Returns:
+            Score.
+        """
+        first_letters = self.get_first_letters(candidate)
+        # This is a heuristic, and can be tweaked for better results
+        # Boost first letter matches
+        offset_count = len(positions)
+        score: float = offset_count + len(first_letters.intersection(positions))
+
+        groups = 1
+        last_offset, *offsets = positions
+        for offset in offsets:
+            if offset != last_offset + 1:
+                groups += 1
+            last_offset = offset
+
+        # Boost to favor less groups
+        normalized_groups = (offset_count - (groups - 1)) / offset_count
+        score *= 1 + (normalized_groups * normalized_groups)
+
+        if positions[0] > candidate.rfind("/"):
+            score *= 2
+        return score
+
+    def _match(
+        self, query: str, candidate: str
+    ) -> Iterable[tuple[float, Sequence[int]]]:
+        letter_positions: list[list[int]] = []
+        position = 0
+
+        if not self.case_sensitive:
+            candidate = candidate.casefold()
+            query = query.casefold()
+
+        score = self.score
+
+        for offset, letter in enumerate(query):
+            last_index = len(candidate) - offset
+            positions: list[int] = []
+            letter_positions.append(positions)
+            index = position
+            while (location := candidate.find(letter, index)) != -1:
+                positions.append(location)
+                index = location + 1
+                if index >= last_index:
+                    break
+            if not positions:
+                yield (0.0, ())
+                return
+            position = positions[0] + 1
+
+        possible_offsets: list[list[int]] = []
+        query_length = len(query)
+
+        def get_offsets(offsets: list[int], positions_index: int) -> None:
+            """Recursively match offsets.
+
+            Args:
+                offsets: A list of offsets.
+                positions_index: Index of query letter.
+
+            """
+            for offset in letter_positions[positions_index]:
+                if not offsets or offset > offsets[-1]:
+                    new_offsets = [*offsets, offset]
+                    if len(new_offsets) == query_length:
+                        possible_offsets.append(new_offsets)
+                    else:
+                        get_offsets(new_offsets, positions_index + 1)
+
+        get_offsets([], 0)
+        for offsets in possible_offsets:
+            yield score(candidate, offsets), offsets
+
+
+_fuzzy_search = PathFuzzySearch(case_sensitive=False)
+
+
+def match_path(query_path: tuple[str, str]) -> tuple[float, Sequence[int], str]:
+    global _fuzzy_search
+    query, path = query_path
+    score, indices = _fuzzy_search.match(query, path)
+    return (
+        score,
+        tuple(indices),
+        path,
+    )

package/tui/about.py

@@ -0,0 +1,95 @@
+import os
+from importlib.metadata import version
+import platform
+from string import Template
+
+from tui.app import A2TUIApp
+from tui import paths
+from tui import get_version
+
+ABOUT_TEMPLATE = Template(
+    """\
+# About A2TUI v${TOAD_VERSION}
+
+© Will McGugan.
+                          
+A2TUI is licensed under the terms of the [GNU AFFERO GENERAL PUBLIC LICENSE](https://www.gnu.org/licenses/agpl-3.0.txt).
+
+
+## Config
+
+config read from `$SETTINGS_PATH`
+                                       
+```json
+$CONFIG                       
+```
+
+## Paths
+
+| Name | Path |
+| --- | --- |
+| App data | `$DATA_PATH` |
+| App state | `$STATE_PATH` |
+| App logs | `$LOG_PATH` |
+
+                          
+## System
+
+| System | Version |
+| --- | --- |
+| Python | $PYTHON |
+| OS | $PLATFORM |
+| Terminal | $TERMINAL |
+
+## Dependencies
+
+| Library | Version |
+| --- | --- | 
+| A2TUI | $TOAD_VERSION |
+| Textual | $TEXTUAL_VERSION |
+| Rich | $RICH_VERSION |
+                          
+## Environment
+
+| Environment variable | Value |                
+| --- | --- |
+| `SHELL` | $SHELL |
+| `TERM` | $TERM |
+| `COLORTERM` | $COLORTERM |
+| `TERM_PROGRAM` | $TERM_PROGRAM |
+| `TERM_PROGRAM_VERSION` | $TERM_PROGRAM_VERSION |
+"""
+)
+
+
+def render(app: A2TUIApp) -> str:
+    """Render about markdown.
+
+    Returns:
+        Markdown string.
+    """
+
+    try:
+        config: str | None = app.settings_path.read_text()
+    except Exception:
+        config = None
+
+    template_data = {
+        "COLORTERM": os.environ.get("COLORTERM", ""),
+        "CONFIG": config,
+        "DATA_PATH": paths.get_data(),
+        "LOG_PATH": paths.get_log(),
+        "STATE_PATH": paths.get_state(),
+        "PLATFORM": platform.platform(),
+        "PYTHON": f"{platform.python_implementation()} {platform.python_version()}",
+        "RICH_VERSION": version("rich"),
+        "SETTINGS_PATH": str(app.settings_path),
+        "SHELL": os.environ.get("SHELL", ""),
+        "TERM_PROGRAM_VERSION": os.environ.get("TERM_PROGRAM_VERSION", ""),
+        "TERM_PROGRAM": os.environ.get("TERM_PROGRAM", ""),
+        "TERM": os.environ.get("TERM", ""),
+        "TEXTUAL_VERSION": version("textual"),
+        "TOAD_VERSION": get_version(),
+        "TERMINAL": app.term_program,
+    }
+    return ABOUT_TEMPLATE.safe_substitute(template_data)