@guanlin4924/devflow-pi 0.1.62 → 0.1.63

package/plugins/devflow-core/skills/workflow-project-context/scripts/validate_initialization_database.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+"""Validate database-backed initialization without trusting Markdown markers."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import sqlite3
+import sys
+from pathlib import Path
+
+
+TERMINAL_STATUSES = {"finished", "failed", "cancelled"}
+VALID_COVERAGE = {"complete", "partial", "unsupported", "not_applicable", "skipped", "failed"}
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--database", required=True)
+    parser.add_argument("--project-id", required=True)
+    parser.add_argument("--workspace-id")
+    parser.add_argument("--run-id")
+    return parser.parse_args()
+
+
+def validate(database: Path, project_id: str, workspace_id: str | None = None, run_id: str | None = None):
+    errors: list[str] = []
+    if not database.is_file():
+        return [f"initialization database does not exist: {database}"]
+    connection = sqlite3.connect(f"file:{database}?mode=ro", uri=True)
+    connection.row_factory = sqlite3.Row
+    try:
+        version = connection.execute("SELECT version FROM schema_meta LIMIT 1").fetchone()
+        if not version or version["version"] != 2:
+            errors.append(f"unsupported initialization schema: {version['version'] if version else 'missing'}")
+        if not connection.execute("SELECT 1 FROM projects WHERE id=?", (project_id,)).fetchone():
+            errors.append("project identity is not registered in the database")
+        foreign_keys = connection.execute("PRAGMA foreign_key_check").fetchall()
+        if foreign_keys:
+            errors.append(f"foreign-key violations: {len(foreign_keys)}")
+        if workspace_id and not connection.execute(
+            "SELECT 1 FROM workspaces WHERE id=? AND project_id=?", (workspace_id, project_id)
+        ).fetchone():
+            errors.append("workspace does not belong to the requested project")
+
+        where = ["project_id=?"]
+        parameters: list[str] = [project_id]
+        if workspace_id:
+            where.append("workspace_id=?")
+            parameters.append(workspace_id)
+        if run_id:
+            where.append("id=?")
+            parameters.append(run_id)
+        runs = connection.execute(
+            f"SELECT * FROM initialization_runs WHERE {' AND '.join(where)} ORDER BY created_at DESC",
+            parameters,
+        ).fetchall()
+        if run_id and not runs:
+            errors.append("requested initialization run was not found")
+        for run in runs[:1] if not run_id else runs:
+            if run["status"] not in TERMINAL_STATUSES | {"preparing", "collecting", "validating"}:
+                errors.append(f"invalid run status: {run['status']}")
+            results = connection.execute(
+                "SELECT repository,kind,status FROM collection_results WHERE run_id=?", (run["id"],)
+            ).fetchall()
+            if any(row["status"] not in VALID_COVERAGE for row in results):
+                errors.append("collection has an invalid coverage status")
+            config = connection.execute(
+                "SELECT config_json FROM scan_configs WHERE id=?", (run["config_id"],)
+            ).fetchone()
+            config_value = json.loads(config["config_json"]) if config else {}
+            required = config_value.get("requiredKinds") or ["asset", "technology", "api", "page", "data_model", "integration", "rule", "toolchain", "evidence", "capability"]
+            repositories = [item.get("name") for item in config_value.get("repositories", []) if item.get("name")]
+            accounted = {(row["repository"], row["kind"]) for row in results if row["status"] not in {"partial", "unsupported", "skipped", "failed"}}
+            missing = sorted(f"{repository}:{kind}" for repository in repositories for kind in required if (repository, kind) not in accounted and ("", kind) not in accounted)
+            if missing:
+                errors.append(f"required collections are unaccounted: {', '.join(missing)}")
+            if run["status"] == "finished":
+                snapshot = connection.execute(
+                    "SELECT * FROM context_snapshots WHERE id=? AND run_id=? AND input_snapshot_id=?",
+                    (run["published_snapshot_id"], run["id"], run["input_snapshot_id"]),
+                ).fetchone()
+                if not snapshot:
+                    errors.append("finished run has no matching immutable context snapshot")
+                else:
+                    try:
+                        index_ref = json.loads(snapshot["index_ref_json"] or "{}")
+                        if config_value.get("mode") == "full":
+                            if index_ref.get("status") != "complete" or not index_ref.get("generation"):
+                                errors.append("full initialization has no completed immutable index reference")
+                            workspace = connection.execute("SELECT location FROM workspaces WHERE id=?", (run["workspace_id"],)).fetchone()
+                            index_path = Path(str(index_ref.get("path", "")))
+                            workspace_root = Path(workspace["location"]).resolve() if workspace else None
+                            index_root = (workspace_root / index_path).resolve() if workspace_root and not index_path.is_absolute() else None
+                            if not index_root or (index_root != workspace_root and workspace_root not in index_root.parents):
+                                errors.append("registered code-index path escapes its workspace")
+                                index_root = None
+                            immutable_relative = Path(str(index_ref.get("immutablePath", "")))
+                            immutable_root = (index_root / immutable_relative).resolve() if index_root and not immutable_relative.is_absolute() else None
+                            if immutable_root and immutable_root != index_root and index_root not in immutable_root.parents:
+                                immutable_root = None
+                                errors.append("registered immutable code-index path escapes its index root")
+                            immutable = immutable_root / "SNAPSHOT.json" if immutable_root else None
+                            if not immutable or not immutable.is_file():
+                                errors.append("registered immutable code-index generation is unavailable")
+                            else:
+                                if f"sha256:{hashlib.sha256(immutable.read_bytes()).hexdigest()}" != index_ref.get("snapshotHash"):
+                                    errors.append("registered immutable code-index snapshot hash mismatch")
+                                if json.loads(immutable.read_text(encoding="utf-8")).get("generation") != index_ref.get("generation"):
+                                    errors.append("immutable code-index generation identity mismatch")
+                        elif config_value.get("mode") == "fast" and (index_ref.get("status"), index_ref.get("reason")) != ("skipped", "explicit_fast_mode"):
+                            errors.append("fast initialization lacks explicit index skip evidence")
+                    except (OSError, ValueError, json.JSONDecodeError) as error:
+                        errors.append(f"invalid code-index reference: {error}")
+                input_row = connection.execute(
+                    "SELECT stable FROM input_snapshots WHERE id=?", (run["input_snapshot_id"],)
+                ).fetchone()
+                if not input_row or not input_row["stable"]:
+                    errors.append("finished run was published from unstable input")
+        missing_evidence = connection.execute(
+            """SELECT COUNT(*) AS count FROM facts f
+               LEFT JOIN evidence e ON e.fact_id=f.id
+               JOIN initialization_runs r ON r.id=f.run_id
+               WHERE r.project_id=? AND f.evidence_level='observed' AND e.id IS NULL""",
+            (project_id,),
+        ).fetchone()["count"]
+        if missing_evidence:
+            errors.append(f"observed facts without source evidence: {missing_evidence}")
+        database_root = database.parent
+        for content in connection.execute("SELECT content_hash,relative_path FROM content_objects"):
+            content_path = database_root / content["relative_path"]
+            if not content_path.is_file():
+                errors.append(f"referenced content is missing: {content['content_hash']}")
+            elif f"sha256:{hashlib.sha256(content_path.read_bytes()).hexdigest()}" != content["content_hash"]:
+                errors.append(f"referenced content hash mismatch: {content['content_hash']}")
+    except (sqlite3.Error, ValueError, json.JSONDecodeError) as error:
+        errors.append(f"database validation error: {error}")
+    finally:
+        connection.close()
+    return errors
+
+
+def main():
+    args = parse_args()
+    errors = validate(Path(args.database).resolve(), args.project_id, args.workspace_id, args.run_id)
+    if errors:
+        for error in errors:
+            print(error, file=sys.stderr)
+        return 1
+    print("Initialization database validation passed.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/plugins/devflow-intel/extensions/devflow-intel.ts

@@ -53,8 +53,12 @@ export default function devflowIntel(pi: ExtensionAPI) {
     label: "Devflow Code Index",
     description: "Scan, validate, audit, or query the deterministic project code index.",
     parameters: z.object({
-      action: z.enum(["scan", "validate", "audit", "query"]),
+      action: z.enum(["scan", "validate", "audit", "query", "relations"]),
       term: z.string().optional(),
+      object: z.string().optional(),
+      snapshot: z.string().optional(),
+      depth: z.number().int().min(0).max(20).default(3),
+      includeHeuristic: z.boolean().default(false),
       limit: z.number().int().min(1).max(100).default(20),
       changedFiles: z.array(z.string()).default([]),
     }),
@@ -74,11 +78,17 @@ export default function devflowIntel(pi: ExtensionAPI) {
         args.push("--index", ".planning/code-index");
       } else if (params.action === "audit") {
         args.push("--root", ctx.cwd, "--index", ".planning/code-index", "--skill-root", skillRoot);
-      } else {
+      } else if (params.action === "query") {
         if (!params.term) {
           return render({ ok: false, exitCode: 2, stdout: "", stderr: "term is required" }, {});
         }
         args.push("--index", ".planning/code-index", "--term", params.term, "--limit", String(params.limit));
+        if (params.snapshot) args.push("--snapshot", params.snapshot);
+      } else {
+        if (!params.object) return render({ ok: false, exitCode: 2, stdout: "", stderr: "object is required" }, {});
+        args.push("--index", ".planning/code-index", "--object", params.object, "--depth", String(params.depth), "--limit", String(params.limit));
+        if (params.snapshot) args.push("--snapshot", params.snapshot);
+        if (params.includeHeuristic) args.push("--include-heuristic");
       }
       return render(await run(args, ctx.cwd), { action: params.action });
     },

package/plugins/devflow-intel/skills/workflow-code-index/scripts/adapters/generic_text.py

@@ -40,7 +40,7 @@ class GenericTextAdapter(Adapter):
         return 1
 
     def version(self) -> str:
-        return "1"
+        return "2"
 
     def parse_file(self, codebase, file_record, text) -> ParseResult:
         path = file_record["path"]
@@ -77,9 +77,10 @@ class GenericTextAdapter(Adapter):
                 )
             )
 
-        line_ranges = _line_ranges([file_symbol] + extracted)
         for lineno, line in enumerate(text.splitlines(), start=1):
-            owner = _owner_for_line(line_ranges, lineno, file_symbol["id"])
+            # Regex ranges are not syntax scopes. Keep generic relations at file
+            # level instead of presenting a guessed method owner as exact.
+            owner = file_symbol["id"]
             for target in _extract_imports(line, language):
                 relations.append(
                     _relation(
@@ -92,7 +93,7 @@ class GenericTextAdapter(Adapter):
                         to_external=f"import:{target}",
                     )
                 )
-            for target in _extract_calls(line):
+            for target in _extract_calls(line, language):
                 relations.append(
                     _relation(
                         owner,
@@ -102,6 +103,7 @@ class GenericTextAdapter(Adapter):
                         self.parser_id,
                         confidence="heuristic",
                         to_external=f"call:{target}",
+                        metadata={"resolution": "unresolved_text", "scope": "file"},
                     )
                 )
             for relation_type, external in _extract_resources(line):
@@ -212,9 +214,12 @@ def _extract_imports(line: str, language: str) -> List[str]:
     return result
 
 
-def _extract_calls(line: str) -> List[str]:
+def _extract_calls(line: str, language: str = "") -> List[str]:
     if line.strip().startswith(("#", "//", "*", "/*")):
         return []
+    # A declaration is evidence for a symbol, not a call to that symbol.
+    if _symbol_matches(line, language):
+        return []
     result = []
     for match in re.finditer(r"\b([A-Za-z_][A-Za-z0-9_]*)\s*\(", line):
         name = match.group(1)
@@ -280,8 +285,7 @@ def _line_ranges(symbols: List[Dict]):
 
 
 def _owner_for_line(ranges, line, fallback):
-    for start, end, symbol_id in ranges:
-        if start <= line <= end:
-            return symbol_id
-    return fallback
-
+    candidates = [item for item in ranges if item[0] <= line <= item[1]]
+    if not candidates:
+        return fallback
+    return min(candidates, key=lambda item: (item[1] - item[0], -item[0]))[2]

package/plugins/devflow-intel/skills/workflow-code-index/scripts/adapters/python_ast.py

@@ -0,0 +1,124 @@
+import ast
+from pathlib import Path
+from typing import Dict, List
+
+from adapters.base import Adapter, ParseResult
+from adapters.generic_text import GenericTextAdapter, _relation, _symbol
+
+
+class PythonAstAdapter(Adapter):
+    name = "python-ast"
+
+    def __init__(self):
+        self.fallback = GenericTextAdapter()
+
+    def detect(self, codebase, files, manifests) -> int:
+        return 100 if any(path.suffix.lower() == ".py" for path in files) else 0
+
+    def version(self) -> str:
+        return "1"
+
+    def parse_file(self, codebase, file_record, text) -> ParseResult:
+        if file_record["language"] != "python":
+            return self.fallback.parse_file(codebase, file_record, text)
+        path = file_record["path"]
+        file_symbol = _symbol(
+            codebase.name, "python", "file", Path(path).name, path, 1,
+            max(1, len(text.splitlines())), file_record["content_hash"],
+            qualified_name=path, parser=self.parser_id,
+        )
+        try:
+            tree = ast.parse(text, filename=path)
+        except SyntaxError as error:
+            fallback = self.fallback.parse_file(codebase, file_record, text)
+            fallback.diagnostics.append({
+                "codebase": codebase.name, "path": path, "line": error.lineno or 1,
+                "severity": "warning", "kind": "parse_failed",
+                "message": f"python AST parse failed; generic fallback used: {error.msg}",
+                "parser": self.parser_id,
+            })
+            return fallback
+        visitor = _PythonVisitor(codebase.name, path, file_record["content_hash"], file_symbol, self.parser_id)
+        visitor.visit(tree)
+        return ParseResult(
+            symbols=[file_symbol, *visitor.symbols],
+            relations=visitor.contains + visitor.relations,
+            diagnostics=[],
+        )
+
+
+class _PythonVisitor(ast.NodeVisitor):
+    def __init__(self, codebase: str, path: str, content_hash: str, file_symbol: Dict, parser: str):
+        self.codebase = codebase
+        self.path = path
+        self.content_hash = content_hash
+        self.file_symbol = file_symbol
+        self.parser = parser
+        self.symbols: List[Dict] = []
+        self.contains: List[Dict] = []
+        self.relations: List[Dict] = []
+        self.stack: List[Dict] = [file_symbol]
+
+    def _definition(self, node, kind: str):
+        parent = self.stack[-1]
+        qualified = f"{parent['qualified_name']}::{node.name}"
+        symbol = _symbol(
+            self.codebase, "python", kind, node.name, self.path,
+            node.lineno, getattr(node, "end_lineno", node.lineno), self.content_hash,
+            qualified_name=qualified, signature=self._signature(node), parser=self.parser,
+        )
+        symbol["container_id"] = parent["id"]
+        symbol["metadata"]["scope_resolution"] = "python_ast"
+        self.symbols.append(symbol)
+        self.contains.append(_relation(parent["id"], "contains", self.path, node.lineno, self.parser, "exact", to_id=symbol["id"], metadata={"extraction": "python_ast"}))
+        self.stack.append(symbol)
+        self.generic_visit(node)
+        self.stack.pop()
+
+    def visit_ClassDef(self, node):
+        self._definition(node, "class")
+
+    def visit_FunctionDef(self, node):
+        parent_kind = self.stack[-1]["kind"]
+        self._definition(node, "method" if parent_kind == "class" else ("test" if node.name.startswith("test") else "function"))
+
+    def visit_AsyncFunctionDef(self, node):
+        self.visit_FunctionDef(node)
+
+    def visit_Import(self, node):
+        for alias in node.names:
+            self.relations.append(_relation(self.stack[-1]["id"], "imports", self.path, node.lineno, self.parser, "exact", to_external=f"import:{alias.name}", metadata={"alias": alias.asname or alias.name}))
+
+    def visit_ImportFrom(self, node):
+        module = "." * node.level + (node.module or "")
+        for alias in node.names:
+            self.relations.append(_relation(self.stack[-1]["id"], "imports", self.path, node.lineno, self.parser, "exact", to_external=f"import:{module}.{alias.name}".rstrip("."), metadata={"alias": alias.asname or alias.name}))
+
+    def visit_Call(self, node):
+        target = self._call_name(node.func)
+        if target:
+            self.relations.append(_relation(
+                self.stack[-1]["id"], "calls", self.path, node.lineno, self.parser,
+                "inferred" if "." not in target else "heuristic",
+                to_external=f"call:{target}",
+                metadata={"resolution": "lexical_name" if "." not in target else "receiver_unresolved", "extraction": "python_ast"},
+            ))
+        self.generic_visit(node)
+
+    @staticmethod
+    def _call_name(node):
+        if isinstance(node, ast.Name):
+            return node.id
+        if isinstance(node, ast.Attribute):
+            parent = _PythonVisitor._call_name(node.value)
+            return f"{parent}.{node.attr}" if parent else node.attr
+        return None
+
+    @staticmethod
+    def _signature(node):
+        arguments = [argument.arg for argument in [*node.args.posonlyargs, *node.args.args, *node.args.kwonlyargs]]
+        if node.args.vararg:
+            arguments.append(f"*{node.args.vararg.arg}")
+        if node.args.kwarg:
+            arguments.append(f"**{node.args.kwarg.arg}")
+        return f"{node.name}({', '.join(arguments)})"

package/plugins/devflow-intel/skills/workflow-code-index/scripts/adapters/registry.py

@@ -1,9 +1,19 @@
 from .generic_text import GenericTextAdapter
+from .python_ast import PythonAstAdapter
+from .structured_scope import StructuredScopeAdapter
 
 
 class AdapterRegistry:
     def __init__(self):
-        self.adapters = [GenericTextAdapter()]
+        self.adapters = [PythonAstAdapter(), StructuredScopeAdapter(), GenericTextAdapter()]
+
+    def adapter_for_file(self, codebase, file_record):
+        language = file_record.get("language")
+        if language == "python":
+            return self.adapters[0]
+        if language in {"typescript", "javascript", "ruby"}:
+            return self.adapters[1]
+        return self.adapters[-1]
 
     def adapters_for(self, codebase, files, manifests):
         scored = []
@@ -14,4 +24,3 @@ class AdapterRegistry:
         if not scored:
             return [GenericTextAdapter()]
         return [adapter for _, adapter in sorted(scored, key=lambda item: item[0], reverse=True)]
-

package/plugins/devflow-intel/skills/workflow-code-index/scripts/adapters/structured_scope.py

@@ -0,0 +1,121 @@
+import re
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+from adapters.base import Adapter, ParseResult
+from adapters.generic_text import GenericTextAdapter, _extract_calls, _extract_imports, _relation, _symbol
+
+
+SUPPORTED = {"typescript", "javascript", "ruby"}
+
+
+class StructuredScopeAdapter(Adapter):
+    """Conservative lexical scopes for languages unavailable to Python AST.
+
+    This adapter never labels target resolution exact. It improves declaration
+    boundaries and ownership while declaring receiver/dynamic gaps in metadata.
+    """
+    name = "structured-scope"
+
+    def __init__(self):
+        self.fallback = GenericTextAdapter()
+
+    def detect(self, codebase, files, manifests) -> int:
+        return 80 if any(path.suffix.lower() in {".ts", ".tsx", ".js", ".jsx", ".rb"} for path in files) else 0
+
+    def version(self) -> str:
+        return "1"
+
+    def parse_file(self, codebase, file_record, text) -> ParseResult:
+        language = file_record["language"]
+        if language not in SUPPORTED:
+            return self.fallback.parse_file(codebase, file_record, text)
+        return self._ruby(codebase, file_record, text) if language == "ruby" else self._brace_language(codebase, file_record, text)
+
+    def _brace_language(self, codebase, file_record, text):
+        lines = text.splitlines()
+        file_symbol = self._file(codebase, file_record, len(lines))
+        declarations: List[Tuple[int, str, str, str]] = []
+        pattern = re.compile(r"\b(class|interface|function)\s+([A-Za-z_$][\w$]*)\s*([^\n{]*)|\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>")
+        for number, line in enumerate(lines, 1):
+            clean = _without_strings_and_comments(line)
+            match = pattern.search(clean)
+            method = re.match(r"^\s*(?:(?:public|private|protected|static|async|readonly|override)\s+)*([A-Za-z_$][\w$]*)\s*\([^;]*\)\s*(?::[^={]+)?\s*\{", clean)
+            if not match:
+                if method and method.group(1) not in {"if", "for", "while", "switch", "catch", "constructor"}:
+                    declarations.append((number, "function", method.group(1), line.strip()))
+                continue
+            keyword, named, tail, arrow = match.groups()
+            name = named or arrow
+            kind = "class" if keyword == "class" else "interface" if keyword == "interface" else "function"
+            declarations.append((number, kind, name, line.strip()))
+        symbols = self._scoped_symbols(codebase, file_record, lines, declarations, file_symbol, brace=True)
+        return self._relations(codebase, file_record, lines, file_symbol, symbols)
+
+    def _ruby(self, codebase, file_record, text):
+        lines = text.splitlines(); file_symbol = self._file(codebase, file_record, len(lines)); declarations = []
+        for number, line in enumerate(lines, 1):
+            match = re.match(r"^\s*(class|module|def)\s+(?:self\.)?([A-Za-z_][\w!?=]*)", _without_strings_and_comments(line))
+            if match:
+                keyword, name = match.groups(); declarations.append((number, "class" if keyword == "class" else "module" if keyword == "module" else "function", name, line.strip()))
+        symbols = self._scoped_symbols(codebase, file_record, lines, declarations, file_symbol, brace=False)
+        return self._relations(codebase, file_record, lines, file_symbol, symbols)
+
+    def _file(self, codebase, record, lines):
+        return _symbol(codebase.name, record["language"], "file", Path(record["path"]).name, record["path"], 1, max(1, lines), record["content_hash"], qualified_name=record["path"], parser=self.parser_id)
+
+    def _scoped_symbols(self, codebase, record, lines, declarations, file_symbol, brace):
+        symbols: List[Dict] = []
+        for start, kind, name, signature in declarations:
+            end = _brace_end(lines, start) if brace else _ruby_end(lines, start)
+            containers = [symbol for symbol in symbols if symbol["line_start"] < start <= symbol["line_end"]]
+            parent = min(containers, key=lambda item: item["line_end"] - item["line_start"]) if containers else file_symbol
+            adjusted = "method" if kind == "function" and parent["kind"] == "class" else kind
+            symbol = _symbol(codebase.name, record["language"], adjusted, name, record["path"], start, max(start, end), record["content_hash"], qualified_name=f"{parent['qualified_name']}::{name}", signature=signature[:500], parser=self.parser_id)
+            symbol["container_id"] = parent["id"]
+            symbol["metadata"].update({"scope_resolution": "structured_lexical", "scope_confidence": "inferred"})
+            symbols.append(symbol)
+        return symbols
+
+    def _relations(self, codebase, record, lines, file_symbol, symbols):
+        relations = []
+        for symbol in symbols:
+            relations.append(_relation(symbol["container_id"] or file_symbol["id"], "contains", record["path"], symbol["line_start"], self.parser_id, "inferred", to_id=symbol["id"], metadata={"extraction": "structured_lexical"}))
+        for number, line in enumerate(lines, 1):
+            owners = [symbol for symbol in symbols if symbol["kind"] in {"function", "method", "test"} and symbol["line_start"] < number <= symbol["line_end"]]
+            owner = min(owners, key=lambda item: item["line_end"] - item["line_start"])["id"] if owners else file_symbol["id"]
+            for target in _extract_imports(line, record["language"]):
+                relations.append(_relation(owner, "imports", record["path"], number, self.parser_id, "inferred", to_external=f"import:{target}", metadata={"extraction": "structured_lexical"}))
+            for target in _extract_calls(line, record["language"]):
+                receiver = bool(re.search(rf"\.\s*{re.escape(target)}\s*\(", line))
+                relations.append(_relation(owner, "calls", record["path"], number, self.parser_id, "heuristic", to_external=f"call:{target}", metadata={"resolution": "receiver_unresolved" if receiver else "name_only", "allow_unique_name_resolution": not receiver, "dynamic_limitations": True}))
+        return ParseResult(symbols=[file_symbol, *symbols], relations=relations, diagnostics=[])
+
+
+def _without_strings_and_comments(line: str) -> str:
+    line = re.sub(r"(['\"])(?:\\.|(?!\1).)*\1", "''", line)
+    return re.sub(r"//.*$|#.*$", "", line)
+
+
+def _brace_end(lines: List[str], start: int) -> int:
+    depth = 0; opened = False
+    for number in range(start, len(lines) + 1):
+        clean = _without_strings_and_comments(lines[number - 1])
+        for character in clean:
+            if character == "{": depth += 1; opened = True
+            elif character == "}" and opened:
+                depth -= 1
+                if depth == 0: return number
+    return start
+
+
+def _ruby_end(lines: List[str], start: int) -> int:
+    depth = 0
+    opener = re.compile(r"^\s*(?:class|module|def|if|unless|case|begin|while|until|for)\b|\bdo\s*(?:\|[^|]*\|)?\s*$")
+    for number in range(start, len(lines) + 1):
+        clean = _without_strings_and_comments(lines[number - 1])
+        if opener.search(clean): depth += 1
+        if re.match(r"^\s*end\b", clean):
+            depth -= 1
+            if depth <= 0: return number
+    return start