llmcode-cli 1.0.0__py3-none-any.whl

llm_code/runtime/permissions.py

@@ -0,0 +1,200 @@
+"""Permission policy for tool execution authorization."""
+from __future__ import annotations
+
+import fnmatch
+import logging
+from enum import Enum
+
+from llm_code.tools.base import PermissionLevel
+
+_log = logging.getLogger(__name__)
+
+
+class PermissionMode(Enum):
+    READ_ONLY = "read_only"
+    WORKSPACE_WRITE = "workspace_write"
+    FULL_ACCESS = "full_access"
+    PROMPT = "prompt"
+    AUTO_ACCEPT = "auto_accept"
+    PLAN = "plan"
+
+
+class PermissionOutcome(Enum):
+    ALLOW = "allow"
+    DENY = "deny"
+    NEED_PROMPT = "need_prompt"
+    NEED_PLAN = "need_plan"
+
+
+# Numeric levels for comparison (higher = more permissive)
+_LEVEL_RANK: dict[PermissionLevel, int] = {
+    PermissionLevel.READ_ONLY: 0,
+    PermissionLevel.WORKSPACE_WRITE: 1,
+    PermissionLevel.FULL_ACCESS: 2,
+}
+
+# Maximum permission level each mode allows without prompting
+_MODE_MAX_LEVEL: dict[PermissionMode, int] = {
+    PermissionMode.READ_ONLY: 0,
+    PermissionMode.WORKSPACE_WRITE: 1,
+    PermissionMode.FULL_ACCESS: 2,
+    PermissionMode.AUTO_ACCEPT: 2,
+    PermissionMode.PROMPT: -1,  # PROMPT handled separately
+    PermissionMode.PLAN: 2,  # PLAN handled separately; max level unused but set for safety
+}
+
+
+def detect_shadowed_rules(
+    allow_tools: frozenset[str],
+    deny_tools: frozenset[str],
+    mode: PermissionMode,
+) -> list[str]:
+    """Return warning messages for conflicting or redundant permission rules.
+
+    Detects three categories of problems:
+    - Allow rules shadowed by deny rules (same tool in both lists).
+    - Allow rules that are unnecessary because the mode already allows them.
+    - Deny rules that are unnecessary because the mode already blocks them.
+
+    Args:
+        allow_tools: Explicit allow list.
+        deny_tools: Explicit deny list.
+        mode: The active permission mode.
+
+    Returns:
+        A list of human-readable warning strings (empty when no issues found).
+    """
+    warnings: list[str] = []
+
+    # 1. Allow rules shadowed by deny rules
+    shadowed = allow_tools & deny_tools
+    for tool in sorted(shadowed):
+        warnings.append(
+            f"Rule conflict: '{tool}' appears in both allow_tools and deny_tools; "
+            "deny takes precedence — allow rule is ineffective."
+        )
+
+    # 2. Allow rules unnecessary because mode already allows them
+    # AUTO_ACCEPT and FULL_ACCESS allow everything; WORKSPACE_WRITE allows up to
+    # workspace_write level — but without per-tool level info we can only flag
+    # modes that unconditionally allow all non-denied tools.
+    unconditional_allow_modes = {PermissionMode.AUTO_ACCEPT, PermissionMode.FULL_ACCESS}
+    if mode in unconditional_allow_modes:
+        for tool in sorted(allow_tools - deny_tools):
+            warnings.append(
+                f"Redundant allow rule: '{tool}' is already allowed by mode '{mode.value}'; "
+                "explicit allow entry has no effect."
+            )
+
+    # 3. Deny rules unnecessary because mode already blocks them
+    # READ_ONLY blocks WORKSPACE_WRITE and FULL_ACCESS tools; without per-tool
+    # level info we flag the case where mode=READ_ONLY and a tool is in deny_tools
+    # while also not in allow_tools (i.e. it would be denied by the mode anyway).
+    # The most deterministic check: PROMPT mode never auto-allows elevated tools,
+    # but it does prompt — so denying explicitly is meaningful there.
+    # READ_ONLY mode blocks everything above READ_ONLY already.
+    if mode == PermissionMode.READ_ONLY:
+        # In READ_ONLY mode all non-read-only tools are blocked anyway.
+        # Explicit deny entries for tools that mode would block are redundant.
+        # We flag tools that are denied but not in allow_tools (since allow overrides
+        # mode, an allow+deny combo is already caught above).
+        redundant_denies = deny_tools - allow_tools
+        for tool in sorted(redundant_denies):
+            warnings.append(
+                f"Redundant deny rule: '{tool}' is already blocked by mode 'read_only'; "
+                "explicit deny entry has no effect."
+            )
+
+    return warnings
+
+
+class PermissionPolicy:
+    def __init__(
+        self,
+        mode: PermissionMode,
+        allow_tools: frozenset[str] = frozenset(),
+        deny_tools: frozenset[str] = frozenset(),
+        deny_patterns: tuple[str, ...] = (),
+        rbac: object | None = None,  # RBACEngine, loosely typed to avoid circular import
+    ) -> None:
+        self._mode = mode
+        self._allow_tools = allow_tools
+        self._deny_tools = deny_tools
+        self._deny_patterns = deny_patterns
+        self._rbac = rbac
+
+        # Warn about conflicting or redundant rules at construction time
+        for warning in detect_shadowed_rules(allow_tools, deny_tools, mode):
+            _log.warning("PermissionPolicy: %s", warning)
+
+    def authorize(
+        self,
+        tool_name: str,
+        required: PermissionLevel,
+        effective_level: PermissionLevel | None = None,
+        identity: object | None = None,  # AuthIdentity
+    ) -> PermissionOutcome:
+        """Determine whether a tool invocation is authorized.
+
+        Precedence:
+          0. RBAC check (if engine and identity provided) → DENY
+          1. deny_tools / deny_patterns → DENY
+          2. allow_tools → ALLOW
+          3. AUTO_ACCEPT → always ALLOW
+          4. PROMPT mode: READ_ONLY always allowed, elevated → NEED_PROMPT
+          5. Other modes: compare effective level vs mode max level
+
+        Args:
+            tool_name: The name of the tool being authorized.
+            required: The tool's declared required permission level.
+            effective_level: If provided, used instead of ``required`` for
+                level comparisons (e.g. after safety analysis determines the
+                actual operation is less or more privileged than declared).
+                Deny/allow lists still take full precedence.
+            identity: Optional AuthIdentity for RBAC checks.
+        """
+        # Use effective_level for comparisons when provided, else fall back to required
+        level = effective_level if effective_level is not None else required
+
+        # 0. RBAC check (if engine and identity provided)
+        if self._rbac is not None and identity is not None:
+            if not self._rbac.is_allowed(identity, f"tool:{tool_name}"):
+                return PermissionOutcome.DENY
+
+        # 1. Deny list and patterns always win
+        if tool_name in self._deny_tools:
+            return PermissionOutcome.DENY
+        for pattern in self._deny_patterns:
+            if fnmatch.fnmatch(tool_name, pattern):
+                return PermissionOutcome.DENY
+
+        # 2. Explicit allow list overrides mode restrictions
+        if tool_name in self._allow_tools:
+            return PermissionOutcome.ALLOW
+
+        # 3. AUTO_ACCEPT allows everything
+        if self._mode == PermissionMode.AUTO_ACCEPT:
+            return PermissionOutcome.ALLOW
+
+        # 4. PROMPT mode: read-only is always allowed, elevated needs prompt
+        if self._mode == PermissionMode.PROMPT:
+            if level == PermissionLevel.READ_ONLY:
+                return PermissionOutcome.ALLOW
+            return PermissionOutcome.NEED_PROMPT
+
+        # 4b. PLAN mode: read-only always allowed, elevated needs planning confirmation
+        if self._mode == PermissionMode.PLAN:
+            if level == PermissionLevel.READ_ONLY:
+                return PermissionOutcome.ALLOW
+            return PermissionOutcome.NEED_PLAN
+
+        # 5. Level-based comparison for READ_ONLY, WORKSPACE_WRITE, FULL_ACCESS modes
+        level_rank = _LEVEL_RANK[level]
+        mode_max = _MODE_MAX_LEVEL[self._mode]
+        if level_rank <= mode_max:
+            return PermissionOutcome.ALLOW
+        return PermissionOutcome.DENY
+
+    def allow_tool(self, tool_name: str) -> None:
+        """Dynamically add a tool to the allow list (e.g. after user approves 'always')."""
+        self._allow_tools = self._allow_tools | frozenset({tool_name})

llm_code/runtime/plan.py

@@ -0,0 +1,45 @@
+"""Plan mode data structures for presenting tool operations before execution."""
+from __future__ import annotations
+
+import dataclasses
+
+
+@dataclasses.dataclass(frozen=True)
+class PlanEntry:
+    tool_name: str
+    args: dict
+    summary: str
+
+
+@dataclasses.dataclass(frozen=True)
+class PlanSummary:
+    entries: tuple[PlanEntry, ...]
+
+    def render(self) -> str:
+        if not self.entries:
+            return "No operations in plan."
+        lines = [f"Plan ({len(self.entries)} operations)\n"]
+        for i, entry in enumerate(self.entries, 1):
+            lines.append(f"  {i}. [{entry.tool_name}] {entry.summary}")
+        return "\n".join(lines)
+
+
+def summarize_tool_call(name: str, args: dict) -> str:
+    """Return a human-readable summary of a tool call for plan mode display."""
+    if name == "edit_file":
+        path = args.get("file_path", "?")
+        old = args.get("old_string", "")
+        new = args.get("new_string", "")
+        old_p = old[:40] + "..." if len(old) > 40 else old
+        new_p = new[:40] + "..." if len(new) > 40 else new
+        return f"Edit {path}: '{old_p}' -> '{new_p}'"
+    if name == "write_file":
+        path = args.get("file_path", "?")
+        content = args.get("content", "")
+        return f"Create {path} ({len(content)} chars)"
+    if name == "bash":
+        cmd = args.get("command", "?")
+        preview = cmd[:60] + "..." if len(cmd) > 60 else cmd
+        return f"Run: {preview}"
+    params = ", ".join(f"{k}={repr(v)[:30]}" for k, v in list(args.items())[:3])
+    return f"{name}({params})"

llm_code/runtime/prompt.py

@@ -0,0 +1,238 @@
+"""System prompt builder for the conversation runtime."""
+from __future__ import annotations
+
+import dataclasses
+import json
+import platform
+from datetime import date
+from pathlib import Path
+from typing import TYPE_CHECKING, Literal
+
+from llm_code.api.types import ToolDefinition
+from llm_code.runtime.context import ProjectContext
+
+if TYPE_CHECKING:
+    from llm_code.runtime.indexer import ProjectIndex
+    from llm_code.runtime.memory_layers import GovernanceRule
+    from llm_code.runtime.skills import SkillSet
+    from llm_code.task.manager import TaskLifecycleManager
+
+_INTRO = """\
+You are a coding assistant running inside a terminal. \
+You have access to tools that let you read, write, and edit files, \
+search code, and run shell commands. \
+Think step-by-step before taking any action.\
+"""
+
+_BEHAVIOR_RULES = """\
+Rules:
+- Read code before modifying it
+- Do not add features the user did not ask for
+- Do not add error handling or comments unless asked
+- Do not over-engineer or create unnecessary abstractions
+- Three similar lines of code is better than a premature abstraction
+- If something fails, diagnose why before switching approach
+- Report results honestly — do not claim something works without verifying
+- Keep responses concise — lead with the answer, not the reasoning
+- For code changes, show the minimal diff needed
+"""
+
+_XML_TOOL_INSTRUCTIONS = """\
+When you need to use a tool, emit exactly one JSON block wrapped in \
+<tool_call>...</tool_call> XML tags — nothing else on those lines. \
+The JSON must have two keys: "tool" (the tool name) and "args" (an object \
+of parameters). Example:
+<tool_call>{"tool": "read_file", "args": {"path": "/README.md"}}</tool_call>
+Wait for the tool result before continuing.\
+"""
+
+_CACHE_BOUNDARY = "# -- CACHE BOUNDARY --"
+
+# Cache control marker inserted between scope transitions (API-level caching)
+_CACHE_CONTROL_MARKER = json.dumps({"type": "cache_control", "cache_type": "ephemeral"})
+
+ScopeType = Literal["global", "project", "session"]
+
+
+@dataclasses.dataclass(frozen=True)
+class PromptSection:
+    """A single section of the system prompt with scope and priority metadata.
+
+    Scope semantics:
+    - "global":  Behavior rules and tool instructions shared across all projects.
+    - "project": Governance rules, project index, CLAUDE.md — shared across
+                 sessions within the same project.
+    - "session": Environment info, memory, active skills — per-session content.
+
+    Priority controls ordering within the same scope (lower value = earlier).
+    """
+
+    content: str
+    scope: ScopeType
+    priority: int = 0
+
+
+class SystemPromptBuilder:
+    def build(
+        self,
+        context: ProjectContext,
+        tools: tuple[ToolDefinition, ...] = (),
+        native_tools: bool = True,
+        skills: "SkillSet | None" = None,
+        active_skill_content: str | None = None,
+        project_index: "ProjectIndex | None" = None,
+        memory_entries: dict | None = None,
+        memory_summaries: list[str] | None = None,
+        mcp_instructions: dict[str, str] | None = None,
+        governance_rules: "tuple[GovernanceRule, ...] | None" = None,
+        task_manager: "TaskLifecycleManager | None" = None,
+    ) -> str:
+        sections: list[PromptSection] = []
+
+        # ------------------------------------------------------------------ #
+        # GLOBAL scope — governance rules, behavior rules, tool instructions
+        # Shared across all projects; cached at global boundary.
+        # ------------------------------------------------------------------ #
+        sections.append(PromptSection(content=_INTRO, scope="global", priority=0))
+
+        # Governance rules (L0) — injected before behavior rules
+        if governance_rules:
+            gov_lines = ["## Governance Rules\n"]
+            categories: dict[str, list] = {}
+            for rule in governance_rules:
+                categories.setdefault(rule.category, []).append(rule)
+            for cat, cat_rules in categories.items():
+                gov_lines.append(f"### {cat.title()}")
+                for r in cat_rules:
+                    source_name = Path(r.source).name if r.source else "unknown"
+                    gov_lines.append(f"- {r.content} _(from {source_name})_")
+                gov_lines.append("")
+            sections.append(PromptSection(content="\n".join(gov_lines), scope="global", priority=5))
+
+        sections.append(PromptSection(content=_BEHAVIOR_RULES, scope="global", priority=10))
+
+        if not native_tools and tools:
+            sections.append(PromptSection(content=_XML_TOOL_INSTRUCTIONS, scope="global", priority=20))
+            tool_lines = ["Available tools:"]
+            for t in tools:
+                schema_str = json.dumps(t.input_schema, separators=(",", ":"))
+                tool_lines.append(f"  - {t.name}: {t.description}  schema={schema_str}")
+            sections.append(PromptSection(content="\n".join(tool_lines), scope="global", priority=21))
+
+        # Auto skills are relatively stable and treated as global
+        if skills and skills.auto_skills:
+            auto_parts = ["## Active Skills"]
+            for skill in skills.auto_skills:
+                auto_parts.append(f"### {skill.name}\n{skill.content}")
+            sections.append(PromptSection(content="\n\n".join(auto_parts), scope="global", priority=30))
+
+        # ------------------------------------------------------------------ #
+        # PROJECT scope — project index, CLAUDE.md
+        # Shared across sessions in the same project; cached at project boundary.
+        # ------------------------------------------------------------------ #
+
+        # Project index (cache-safe — changes infrequently)
+        if project_index:
+            _KIND_PRIORITY = {"class": 0, "function": 1, "export": 2, "method": 3, "variable": 4}
+            sorted_symbols = sorted(project_index.symbols, key=lambda s: _KIND_PRIORITY.get(s.kind, 99))[:100]
+            lines = [f"  {s.kind} {s.name} — {s.file}:{s.line}" for s in sorted_symbols]
+            sections.append(PromptSection(
+                content=f"## Project Index ({len(project_index.files)} files)\n\n" + "\n".join(lines),
+                scope="project",
+                priority=10,
+            ))
+
+        # Project instructions from CLAUDE.md / INSTRUCTIONS.md
+        if context.instructions:
+            sections.append(PromptSection(
+                content=f"## Project Instructions\n\n{context.instructions}",
+                scope="project",
+                priority=20,
+            ))
+
+        # ------------------------------------------------------------------ #
+        # SESSION scope — environment, memory, active skills (per-session)
+        # ------------------------------------------------------------------ #
+
+        # MCP server instructions (injected per-server, per-session)
+        if mcp_instructions:
+            for server_name, instr in mcp_instructions.items():
+                sections.append(PromptSection(
+                    content=f"## MCP Server: {server_name}\n\n{instr}",
+                    scope="session",
+                    priority=0,
+                ))
+
+        # Active command skill (one-shot, dynamic)
+        if active_skill_content:
+            sections.append(PromptSection(
+                content=f"## Active Skill\n\n{active_skill_content}",
+                scope="session",
+                priority=5,
+            ))
+
+        # Environment section (dynamic — cwd, date, git status)
+        env_lines = [
+            "## Environment",
+            f"- Working directory: {context.cwd}",
+            f"- Platform: {platform.system()}",
+            f"- Date: {date.today().isoformat()}",
+        ]
+        if context.is_git_repo and context.git_status:
+            env_lines.append(f"- Git status:\n```\n{context.git_status}\n```")
+        elif context.is_git_repo:
+            env_lines.append("- Git status: clean")
+        sections.append(PromptSection(content="\n".join(env_lines), scope="session", priority=10))
+
+        # Memory summaries (dynamic — recent session history)
+        if memory_summaries:
+            sections.append(PromptSection(
+                content="## Recent Sessions\n\n" + "\n".join(f"- {s[:200]}" for s in memory_summaries),
+                scope="session",
+                priority=20,
+            ))
+
+        # Memory entries (dynamic — project-scoped key-value memory)
+        if memory_entries:
+            lines = [f"- **{k}**: {v[:200]}" for k, v in memory_entries.items()]
+            sections.append(PromptSection(
+                content="## Project Memory\n\n" + "\n".join(lines),
+                scope="session",
+                priority=21,
+            ))
+
+        # Incomplete tasks from prior sessions (cross-session persistence)
+        if task_manager is not None:
+            from llm_code.task.manager import build_incomplete_tasks_prompt
+            task_section = build_incomplete_tasks_prompt(task_manager)
+            if task_section:
+                sections.append(PromptSection(content=task_section, scope="session", priority=30))
+
+        return self._serialize(sections)
+
+    def _serialize(self, sections: list[PromptSection]) -> str:
+        """Serialize PromptSection list into a single string with cache boundary markers.
+
+        Sections are grouped by scope and sorted by priority within each scope.
+        Cache boundary markers are inserted between scope transitions:
+        - Between global and project scopes
+        - Between project and session scopes
+
+        This allows API-level caching at two boundaries instead of one.
+        """
+        scope_order: dict[ScopeType, int] = {"global": 0, "project": 1, "session": 2}
+        sorted_sections = sorted(sections, key=lambda s: (scope_order[s.scope], s.priority))
+
+        parts: list[str] = []
+        prev_scope: ScopeType | None = None
+
+        for section in sorted_sections:
+            current_scope = section.scope
+            if prev_scope is not None and current_scope != prev_scope:
+                # Insert cache boundary marker between scope transitions
+                parts.append(_CACHE_BOUNDARY)
+                parts.append(_CACHE_CONTROL_MARKER)
+            parts.append(section.content)
+            prev_scope = current_scope
+
+        return "\n\n".join(parts)

llm_code/runtime/repo_map.py

@@ -0,0 +1,174 @@
+"""Repo Map -- AST-based symbol index for codebase overview."""
+from __future__ import annotations
+
+import ast
+import logging
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+_SKIP_DIRS = frozenset({
+    ".git", "__pycache__", "node_modules", ".venv", "venv",
+    ".tox", ".mypy_cache", ".pytest_cache", ".ruff_cache",
+    "dist", "build", ".eggs",
+})
+
+_PYTHON_EXTS = frozenset({".py", ".pyi"})
+_JS_TS_EXTS = frozenset({".js", ".jsx", ".ts", ".tsx"})
+
+_BINARY_EXTS = frozenset({
+    ".pyc", ".pyo", ".so", ".dll", ".png", ".jpg", ".jpeg",
+    ".gif", ".bmp", ".ico", ".zip", ".gz", ".tar", ".whl",
+})
+
+
+@dataclass(frozen=True)
+class ClassSymbol:
+    """A class with its public method names."""
+
+    name: str
+    methods: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True)
+class FileSymbols:
+    """Symbols extracted from a single file."""
+
+    path: str
+    classes: tuple[ClassSymbol, ...] = ()
+    functions: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True)
+class RepoMap:
+    """Immutable collection of per-file symbol summaries."""
+
+    files: tuple[FileSymbols, ...] = ()
+
+    def to_compact(self, max_tokens: int = 2000) -> str:
+        """Render a compact text representation of the repo map.
+
+        Stays within approximately *max_tokens* (estimated as chars / 4).
+        """
+        max_chars = max_tokens * 4
+        lines: list[str] = []
+        total_chars = 0
+
+        for fs in self.files:
+            if not fs.classes and not fs.functions:
+                line = fs.path
+            else:
+                symbols: list[str] = []
+                for cls in fs.classes:
+                    if cls.methods:
+                        symbols.append(f"{cls.name}({', '.join(cls.methods)})")
+                    else:
+                        symbols.append(cls.name)
+                symbols.extend(fs.functions)
+                line = f"{fs.path}: {', '.join(symbols)}"
+
+            line_len = len(line) + 1  # +1 for newline
+            if total_chars + line_len > max_chars:
+                break
+            lines.append(line)
+            total_chars += line_len
+
+        return "\n".join(lines)
+
+
+def build_repo_map(cwd: Path, max_files: int = 100) -> RepoMap:
+    """Build a symbol map of the repository rooted at *cwd*."""
+    source_files: list[Path] = []
+    _collect_source_files(cwd, cwd, source_files)
+    source_files.sort(key=lambda p: str(p.relative_to(cwd)))
+
+    file_symbols: list[FileSymbols] = []
+    for f in source_files[:max_files]:
+        rel = str(f.relative_to(cwd))
+        suffix = f.suffix.lower()
+
+        if suffix in _PYTHON_EXTS:
+            fs = _parse_python(f, rel)
+        elif suffix in _JS_TS_EXTS:
+            fs = _parse_js_ts(f, rel)
+        else:
+            fs = FileSymbols(path=rel)
+
+        file_symbols.append(fs)
+
+    return RepoMap(files=tuple(file_symbols))
+
+
+def _collect_source_files(
+    base: Path, current: Path, out: list[Path],
+) -> None:
+    """Recursively collect source files, skipping irrelevant directories."""
+    try:
+        entries = sorted(current.iterdir(), key=lambda p: p.name)
+    except PermissionError:
+        return
+
+    for entry in entries:
+        if entry.is_dir():
+            if entry.name in _SKIP_DIRS or entry.name.startswith("."):
+                continue
+            _collect_source_files(base, entry, out)
+        elif entry.is_file():
+            if entry.suffix.lower() in _BINARY_EXTS:
+                continue
+            try:
+                if entry.stat().st_size > 100_000:
+                    continue
+            except OSError:
+                continue
+            out.append(entry)
+
+
+def _parse_python(path: Path, rel_path: str) -> FileSymbols:
+    """Parse a Python file using AST to extract classes and functions."""
+    try:
+        source = path.read_text(encoding="utf-8", errors="replace")
+        tree = ast.parse(source, filename=rel_path)
+    except (SyntaxError, OSError):
+        return FileSymbols(path=rel_path)
+
+    classes: list[ClassSymbol] = []
+    functions: list[str] = []
+
+    for node in ast.iter_child_nodes(tree):
+        if isinstance(node, ast.ClassDef):
+            methods = tuple(
+                item.name
+                for item in ast.iter_child_nodes(node)
+                if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef))
+                and not item.name.startswith("_")
+            )
+            classes.append(ClassSymbol(name=node.name, methods=methods))
+        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            if not node.name.startswith("_"):
+                functions.append(node.name)
+
+    return FileSymbols(path=rel_path, classes=tuple(classes), functions=tuple(functions))
+
+
+def _parse_js_ts(path: Path, rel_path: str) -> FileSymbols:
+    """Parse JS/TS file using regex fallback for class/function extraction."""
+    try:
+        source = path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return FileSymbols(path=rel_path)
+
+    classes: list[ClassSymbol] = []
+    functions: list[str] = []
+
+    for match in re.finditer(r"class\s+(\w+)", source):
+        classes.append(ClassSymbol(name=match.group(1)))
+
+    for match in re.finditer(r"(?:export\s+)?function\s+(\w+)", source):
+        functions.append(match.group(1))
+    for match in re.finditer(r"export\s+const\s+(\w+)", source):
+        functions.append(match.group(1))
+
+    return FileSymbols(path=rel_path, classes=tuple(classes), functions=tuple(functions))