nooa-cli 0.0.7__py3-none-any.whl

nooa_cli/completion.py

@@ -0,0 +1,253 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+"""nooa completion — Generate shell completion scripts.
+
+Usage:
+    nooa completion bash     # Print bash completion script
+    nooa completion zsh      # Print zsh completion script
+    nooa completion fish     # Print fish completion script
+    nooa completion install  # Auto-install for current shell
+"""
+
+import os
+from pathlib import Path
+
+import click
+
+# Completion script templates — generated by Click 8.x, embedded to avoid
+# subprocess overhead and capture issues.
+_BASH_SCRIPT = r"""
+%(complete_func)s() {
+    local IFS=$'\n'
+    COMPREPLY=( $( env COMP_WORDS="${COMP_WORDS[*]}" \
+                   COMP_CWORD=$COMP_CWORD \
+                   %(complete_var)s=bash_complete $1 ) )
+    return 0
+}
+
+%(complete_func)ssetup() {
+    complete -o default -F %(complete_func)s %(prog_name)s
+}
+
+%(complete_func)ssetup;
+""".strip()
+
+_ZSH_SCRIPT = r"""
+#compdef %(prog_name)s
+
+%(complete_func)s() {
+    local -a completions
+    local -a completions_with_descriptions
+    local -a response
+    (( ! $+commands[%(prog_name)s] )) && return 1
+
+    response=("${(@f)$(env COMP_WORDS="${words[*]}" COMP_CWORD=$((CURRENT-1)) %(complete_var)s=zsh_complete %(prog_name)s)}")
+
+    for type key descr in ${response}; do
+        if [[ "$type" == "plain" ]]; then
+            if [[ "$descr" == "_" ]]; then
+                completions+=("$key")
+            else
+                completions_with_descriptions+=("$key":"$descr")
+            fi
+        elif [[ "$type" == "dir" ]]; then
+            _path_files -/
+        elif [[ "$type" == "file" ]]; then
+            _path_files -f
+        fi
+    done
+
+    if [ -n "$completions_with_descriptions" ]; then
+        _describe -V unsorted completions_with_descriptions -U
+    fi
+
+    if [ -n "$completions" ]; then
+        compadd -U -V unsorted -a completions
+    fi
+}
+
+if [[ $zsh_eval_context[-1] == loadautofun ]]; then
+    # autoload from fpath
+    %(complete_func)s "$@"
+else
+    compdef %(complete_func)s %(prog_name)s
+fi
+""".strip()
+
+_FISH_SCRIPT = r"""
+complete -c %(prog_name)s -f -a "(env %(complete_var)s=fish_complete COMP_WORDS=(commandline -cp) COMP_CWORD=(commandline -t) %(prog_name)s)"
+""".strip()
+
+
+def _render_script(template: str) -> str:
+    """Render a completion script template with nooa-specific values."""
+    return template % {
+        "complete_func": "_nooa_completion",
+        "complete_var": "_NOOA_COMPLETE",
+        "prog_name": "nooa",
+    }
+
+
+@click.group()
+def completion():
+    """Generate shell completion scripts for nooa.
+
+    \b
+    Quick setup (add to your shell profile):
+
+        # bash (~/.bashrc)
+        eval "$(_NOOA_COMPLETE=bash_source nooa)"
+
+        # zsh (~/.zshrc)
+        eval "$(_NOOA_COMPLETE=zsh_source nooa)"
+
+        # fish (~/.config/fish/config.fish)
+        _NOOA_COMPLETE=fish_source nooa | source
+    """
+
+
+@completion.command()
+def bash():
+    """Print bash completion script.
+
+    \b
+    Usage:
+        eval "$(nooa completion bash)"
+        # Or append to profile:
+        nooa completion bash >> ~/.bashrc
+    """
+    click.echo(_render_script(_BASH_SCRIPT))
+
+
+@completion.command()
+def zsh():
+    """Print zsh completion script.
+
+    \b
+    Usage:
+        eval "$(nooa completion zsh)"
+        # Or append to profile:
+        nooa completion zsh >> ~/.zshrc
+    """
+    click.echo(_render_script(_ZSH_SCRIPT))
+
+
+@completion.command()
+def fish():
+    """Print fish completion script.
+
+    \b
+    Usage:
+        nooa completion fish > ~/.config/fish/completions/nooa.fish
+    """
+    click.echo(_render_script(_FISH_SCRIPT))
+
+
+@completion.command()
+def install():
+    """Auto-detect shell and install completions.
+
+    Detects your current shell and appends the completion script
+    to the appropriate profile file.
+    """
+    shell = _detect_shell()
+    if not shell:
+        click.secho("Could not detect your shell. Use one of:", fg="red")
+        click.echo("  nooa completion bash")
+        click.echo("  nooa completion zsh")
+        click.echo("  nooa completion fish")
+        raise SystemExit(1)
+
+    click.echo(f"Detected shell: {shell}")
+
+    if shell == "bash":
+        profile = Path.home() / ".bashrc"
+        line = 'eval "$(_NOOA_COMPLETE=bash_source nooa)"'
+    elif shell == "zsh":
+        profile = Path.home() / ".zshrc"
+        line = 'eval "$(_NOOA_COMPLETE=zsh_source nooa)"'
+    elif shell == "fish":
+        profile = Path.home() / ".config" / "fish" / "completions" / "nooa.fish"
+        line = None  # Fish uses a completions file with the script directly
+    else:
+        click.secho(f"Unsupported shell: {shell}", fg="red")
+        raise SystemExit(1)
+
+    # Remove stale pre-rename fish completions file if present.
+    if shell == "fish":
+        old_fish = Path.home() / ".config" / "fish" / "completions" / "nemo.fish"
+        if old_fish.exists():
+            old_fish.unlink()
+            click.secho(f"Removed stale pre-rename completions: {old_fish}", fg="yellow")
+
+    # Check if already installed; drop stale pre-rename lines. Old installs
+    # wrote `_NEMO_COMPLETE=... nooa` — now that the `nooa` binary
+    # exists, click ignores the wrong variable and the eval'd help text
+    # errors on every shell startup.
+    if profile.exists():
+        existing = _read_preserving_newlines(profile)
+        line_ending = _detect_line_ending(existing)
+        lines = existing.splitlines()
+        stale_indices = {
+            i for i, ln in enumerate(lines) if "_NEMO_COMPLETE" in ln and "_NOOA_COMPLETE" not in ln
+        }
+        # Also mark preceding comment lines that belong to the same block
+        # (e.g. "# nemo shell completions" immediately above a stale eval).
+        for i in sorted(stale_indices):
+            prev = i - 1
+            while prev >= 0 and prev not in stale_indices:
+                stripped = lines[prev].strip()
+                if stripped.startswith("#") and "nemo" in stripped.lower():
+                    stale_indices.add(prev)
+                    prev -= 1
+                else:
+                    break
+        if stale_indices:
+            cleaned = line_ending.join(ln for i, ln in enumerate(lines) if i not in stale_indices)
+            profile.write_text(cleaned + (line_ending if cleaned else ""))
+            existing = cleaned
+            click.secho(
+                f"Removed stale _NEMO_COMPLETE completion line(s) from {profile}",
+                fg="yellow",
+            )
+        if "_NOOA_COMPLETE" in existing:
+            click.secho(f"Completions already installed in {profile}", fg="green")
+            return
+
+    if shell == "fish":
+        # Fish: write completions file
+        profile.parent.mkdir(parents=True, exist_ok=True)
+        script = _render_script(_FISH_SCRIPT)
+        profile.write_text(script + "\n")
+        click.secho(f"Completions written to {profile}", fg="green")
+    else:
+        # Bash/zsh: append eval one-liner to profile
+        with open(profile, "a") as f:
+            f.write(f"\n# nooa shell completions\n{line}\n")
+        click.secho(f"Completions added to {profile}", fg="green")
+        click.echo(f"Run: source {profile}")
+
+
+def _detect_line_ending(text: str) -> str:
+    """Return the dominant line ending in *text*."""
+    if "\r\n" in text:
+        return "\r\n"
+    return "\n"
+
+
+def _read_preserving_newlines(path: Path) -> str:
+    """Read file without Python's universal newline translation."""
+    with open(path, newline="") as f:
+        return f.read()
+
+
+def _detect_shell() -> str | None:
+    """Detect the current shell."""
+    shell = os.environ.get("SHELL", "")
+    if "zsh" in shell:
+        return "zsh"
+    elif "bash" in shell:
+        return "bash"
+    elif "fish" in shell:
+        return "fish"
+    return None

nooa_cli/tools/_tree_sitter_backend.py

@@ -0,0 +1,351 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+"""Tree-sitter backend for RepoTools.
+
+Provides AST-aware code analysis: symbol extraction and reference finding
+using tree-sitter grammars. Falls back gracefully if grammars are unavailable.
+
+Usage (internal — called by repo_tools.py)::
+
+    from nooa_cli.tools._tree_sitter_backend import (
+        ts_extract_symbols,
+        ts_find_references,
+        TREE_SITTER_AVAILABLE,
+    )
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+try:
+    import tree_sitter as ts
+
+    TREE_SITTER_AVAILABLE = True
+except ImportError:
+    TREE_SITTER_AVAILABLE = False
+
+# Language grammar loaders (lazy-loaded)
+_PARSERS: dict[str, ts.Parser] = {}
+
+# Map language name → grammar module and language loader function.
+_GRAMMAR_MODULES = {
+    "python": ("tree_sitter_python", "language"),
+    "javascript": ("tree_sitter_javascript", "language"),
+    "typescript": ("tree_sitter_typescript", "language_typescript"),
+    "tsx": ("tree_sitter_typescript", "language_tsx"),
+    "go": ("tree_sitter_go", "language"),
+    "rust": ("tree_sitter_rust", "language"),
+}
+
+# Tree-sitter queries for extracting definitions per language
+_DEFINITION_QUERIES = {
+    "python": """
+        (function_definition name: (identifier) @name) @def
+        (class_definition name: (identifier) @name) @def
+    """,
+    "javascript": """
+        (function_declaration name: (identifier) @name) @def
+        (class_declaration name: (identifier) @name) @def
+        (method_definition name: (property_identifier) @name) @def
+        (lexical_declaration
+            (variable_declarator
+                name: (identifier) @name
+                value: (arrow_function))) @def
+    """,
+    "typescript": """
+        (function_declaration name: (identifier) @name) @def
+        (class_declaration name: (identifier) @name) @def
+        (interface_declaration name: (type_identifier) @name) @def
+        (type_alias_declaration name: (type_identifier) @name) @def
+        (method_definition name: (property_identifier) @name) @def
+    """,
+    "go": """
+        (function_declaration name: (identifier) @name) @def
+        (method_declaration name: (field_identifier) @name) @def
+        (type_declaration (type_spec name: (type_identifier) @name)) @def
+    """,
+    "rust": """
+        (function_item name: (identifier) @name) @def
+        (struct_item name: (type_identifier) @name) @def
+        (enum_item name: (type_identifier) @name) @def
+        (trait_item name: (type_identifier) @name) @def
+        (impl_item type: (type_identifier) @name) @def
+    """,
+}
+
+# Tree-sitter queries for finding references (call sites, imports, usages)
+_DEFINITION_QUERIES["tsx"] = _DEFINITION_QUERIES["typescript"]
+
+_REFERENCE_QUERIES = {
+    "python": """
+        (call function: (identifier) @ref)
+        (call function: (attribute attribute: (identifier) @ref))
+        (import_from_statement name: (dotted_name (identifier) @ref))
+        (identifier) @ref
+    """,
+    "javascript": """
+        (call_expression function: (identifier) @ref)
+        (call_expression function: (member_expression property: (property_identifier) @ref))
+        (identifier) @ref
+    """,
+    "typescript": """
+        (call_expression function: (identifier) @ref)
+        (call_expression function: (member_expression property: (property_identifier) @ref))
+        (type_identifier) @ref
+        (identifier) @ref
+    """,
+    "go": """
+        (call_expression function: (identifier) @ref)
+        (call_expression function: (selector_expression field: (field_identifier) @ref))
+        (identifier) @ref
+    """,
+    "rust": """
+        (call_expression function: (identifier) @ref)
+        (call_expression function: (field_expression field: (field_identifier) @ref))
+        (identifier) @ref
+    """,
+}
+_REFERENCE_QUERIES["tsx"] = _REFERENCE_QUERIES["typescript"]
+
+
+def _get_parser(lang: str) -> ts.Parser | None:
+    """Get or create a tree-sitter parser for the given language."""
+    if not TREE_SITTER_AVAILABLE:
+        return None
+
+    if lang in _PARSERS:
+        return _PARSERS[lang]
+
+    grammar = _GRAMMAR_MODULES.get(lang)
+    if not grammar:
+        return None
+    mod_name, loader_name = grammar
+
+    try:
+        import importlib
+
+        grammar_mod = importlib.import_module(mod_name)
+        language_fn = getattr(grammar_mod, loader_name)
+        language = ts.Language(language_fn())
+        parser = ts.Parser(language)
+        _PARSERS[lang] = parser
+        return parser
+    except (ImportError, AttributeError, Exception) as e:
+        logger.debug(f"tree-sitter grammar not available for {lang}: {e}")
+        return None
+
+
+def _query_captures(query: ts.Query, root_node: ts.Node) -> list[tuple[ts.Node, str]]:
+    legacy_captures = getattr(query, "captures", None)
+    if legacy_captures is not None:
+        return legacy_captures(root_node)
+
+    captures = ts.QueryCursor(query).captures(root_node)
+    if isinstance(captures, dict):
+        flattened = [
+            (node, capture_name) for capture_name, nodes in captures.items() for node in nodes
+        ]
+        return sorted(flattened, key=lambda item: item[0].start_byte)
+    return captures
+
+
+def ts_extract_symbols(path: Path, lang: str, max_symbols: int = 200) -> list[str] | None:
+    """Extract symbol definitions using tree-sitter AST parsing.
+
+    Returns a list of formatted symbol lines, or None if tree-sitter
+    is not available for this language (caller should fall back to regex).
+    """
+    parser = _get_parser(lang)
+    if parser is None:
+        return None
+
+    try:
+        source = path.read_bytes()
+        tree = parser.parse(source)
+    except (OSError, Exception) as e:
+        logger.debug(f"tree-sitter parse failed for {path}: {e}")
+        return None
+
+    query_src = _DEFINITION_QUERIES.get(lang)
+    if not query_src:
+        return None
+
+    try:
+        language = parser.language
+        query = language.query(query_src)
+    except Exception as e:
+        logger.debug(f"tree-sitter query compilation failed for {lang}: {e}")
+        return None
+
+    symbols: list[str] = []
+    captures = _query_captures(query, tree.root_node)
+
+    # Process captures — look for @name captures paired with @def
+    seen_lines: set[int] = set()
+    for node, capture_name in captures:
+        if capture_name != "name":
+            continue
+        if len(symbols) >= max_symbols:
+            break
+
+        line = node.start_point[0] + 1  # 1-indexed
+        if line in seen_lines:
+            continue
+        seen_lines.add(line)
+
+        name = source[node.start_byte : node.end_byte].decode("utf-8", errors="replace")
+
+        # Determine kind from the enclosing definition node.
+        parent = node.parent
+        kind = _node_to_kind(parent, lang, source)
+
+        # Calculate indent
+        indent = node.start_point[1]
+        prefix = "  " * (indent // 4) if indent > 0 else ""
+        symbols.append(f"  {line:4d} {prefix}{kind} {name}")
+
+    return symbols if symbols else None
+
+
+def ts_find_references(
+    path: Path, lang: str, name: str, max_results: int = 100
+) -> list[tuple[int, str]] | None:
+    """Find references to a symbol using tree-sitter AST parsing.
+
+    Returns a list of (line_number, line_text) tuples, or None if
+    tree-sitter is not available (caller should fall back to regex).
+
+    Filters out definition sites — only returns usages/call sites.
+    """
+    parser = _get_parser(lang)
+    if parser is None:
+        return None
+
+    try:
+        source = path.read_bytes()
+        tree = parser.parse(source)
+    except (OSError, Exception):
+        return None
+
+    query_src = _REFERENCE_QUERIES.get(lang)
+    if not query_src:
+        return None
+
+    try:
+        language = parser.language
+        query = language.query(query_src)
+    except Exception:
+        return None
+
+    lines = source.decode("utf-8", errors="replace").splitlines()
+    captures = _query_captures(query, tree.root_node)
+
+    # Handle qualified names (e.g. "TraceExplorer.from_file" → match "from_file")
+    search_name = name.split(".")[-1] if "." in name else name
+    qualifier = name.split(".")[0] if "." in name else None
+
+    results: list[tuple[int, str]] = []
+    seen_lines: set[int] = set()
+
+    for node, capture_name in captures:
+        if capture_name != "ref":
+            continue
+        if len(results) >= max_results:
+            break
+
+        node_text = source[node.start_byte : node.end_byte].decode("utf-8", errors="replace")
+        if node_text != search_name:
+            continue
+
+        line = node.start_point[0] + 1  # 1-indexed
+        if line in seen_lines:
+            continue
+
+        # Skip definition sites
+        parent = node.parent
+        if parent and _is_definition_node(parent.type, lang):
+            continue
+
+        # If qualified name, check that qualifier appears on the same line
+        if qualifier and line <= len(lines):
+            line_text = lines[line - 1]
+            if qualifier not in line_text:
+                continue
+
+        seen_lines.add(line)
+        line_text = lines[line - 1] if line <= len(lines) else ""
+        results.append((line, line_text.strip()))
+
+    return results if results else None
+
+
+def _node_to_kind(node: ts.Node | None, lang: str, source: bytes) -> str:
+    """Map a tree-sitter definition node to a human-readable kind string."""
+    if node is None:
+        return "symbol"
+
+    if lang == "python" and node.type == "function_definition":
+        line = source.splitlines()[node.start_point[0]].lstrip()
+        if line.startswith(b"async def "):
+            return "async function"
+
+    if lang == "go" and node.type == "type_spec":
+        for child in node.children:
+            if child.type == "struct_type":
+                return "struct"
+            if child.type == "interface_type":
+                return "interface"
+
+    return _node_type_to_kind(node.type, lang)
+
+
+def _node_type_to_kind(node_type: str, lang: str) -> str:
+    """Map tree-sitter node type to a human-readable kind string."""
+    mapping = {
+        "function_definition": "function",
+        "function_declaration": "function",
+        "function_item": "function",
+        "method_definition": "method",
+        "method_declaration": "method",
+        "class_definition": "class",
+        "class_declaration": "class",
+        "struct_item": "struct",
+        "enum_item": "enum",
+        "trait_item": "trait",
+        "impl_item": "impl",
+        "interface_declaration": "interface",
+        "type_alias_declaration": "type",
+        "type_declaration": "type",
+        "type_spec": "type",
+        "lexical_declaration": "function",
+        "variable_declarator": "function",
+    }
+    return mapping.get(node_type, "symbol")
+
+
+def _is_definition_node(node_type: str, lang: str) -> bool:
+    """Return True if the node type represents a definition (not a reference)."""
+    def_types = {
+        "function_definition",
+        "function_declaration",
+        "function_item",
+        "method_definition",
+        "method_declaration",
+        "class_definition",
+        "class_declaration",
+        "struct_item",
+        "enum_item",
+        "trait_item",
+        "impl_item",
+        "interface_declaration",
+        "type_alias_declaration",
+        "type_declaration",
+        "type_spec",
+        "lexical_declaration",
+        "variable_declarator",
+    }
+    return node_type in def_types

nooa_cli/tools/pyp/__init__.py

@@ -0,0 +1,71 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+"""Async-native composable shell piping in Python with method-chaining streams."""
+
+from nooa.skill import Skill
+from nooa_cli.tools.pyp.errors import PipeError as PipeError
+from nooa_cli.tools.pyp.errors import Result as Result
+from nooa_cli.tools.pyp.errors import make_pipe_error as make_pipe_error
+from nooa_cli.tools.pyp.sources import arun as arun
+from nooa_cli.tools.pyp.sources import cat as cat
+from nooa_cli.tools.pyp.sources import empty as empty
+from nooa_cli.tools.pyp.sources import find as find
+from nooa_cli.tools.pyp.sources import glob as glob
+from nooa_cli.tools.pyp.sources import items as items
+from nooa_cli.tools.pyp.sources import lines as lines
+from nooa_cli.tools.pyp.sources import rg as rg
+from nooa_cli.tools.pyp.sources import run as run
+from nooa_cli.tools.pyp.sources import seq as seq
+from nooa_cli.tools.pyp.sources import stdin as stdin
+from nooa_cli.tools.pyp.stream import Stream as Stream
+
+
+class Pyp(Skill):
+    """Async-native shell piping — source().transforms().sink().
+
+    Build pipelines: pick a source, chain transforms, await a sink.
+    All streaming, all async, all non-blocking.
+
+    Examples::
+
+        # Search logs
+        errors = await self.pyp.cat("app.log").grep("ERROR").head(10).collect()
+
+        # Find files
+        files = await self.pyp.find("src", name="*.py").sort().collect()
+
+        # Ripgrep → count
+        n = await self.pyp.rg("TODO", type_filter="py").count()
+
+        # Shell command → table
+        table = await self.pyp.run("ps aux").head(5).table()
+
+        # Apply function to each line
+        out = await self.pyp.run("ls").xargs(process).collect()
+
+        # Pipeline → file
+        n = await self.pyp.cat("data.csv").grep("error").write("errors.csv")
+
+        # Stream via ShellTools
+        fails = await self.pyp.arun(self.shell, "make test").grep("FAIL").collect()
+
+    Transforms (on any Stream): .grep() .head() .tail() .sort() .uniq()
+    .cut() .sed() .map() .filter() .xargs() .wc() .skip() .strip()
+    .tee() .flatten() .take_while() .drop_while() .pipe()
+
+    Sinks: .collect() .text() .first() .last() .count() .table()
+    .json() .result() .write() .to_set() .to_dict()
+    """
+
+    # Expose all source functions as instance methods
+    cat = staticmethod(cat)
+    run = staticmethod(run)
+    arun = staticmethod(arun)
+    find = staticmethod(find)
+    glob = staticmethod(glob)
+    rg = staticmethod(rg)
+    seq = staticmethod(seq)
+    lines = staticmethod(lines)
+    items = staticmethod(items)
+    empty = staticmethod(empty)
+    stdin = staticmethod(stdin)