@guanlin4924/devflow-pi 0.1.0

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

@@ -0,0 +1,30 @@
+from dataclasses import dataclass, field
+from typing import Dict, List
+
+
+@dataclass
+class ParseResult:
+    symbols: List[Dict] = field(default_factory=list)
+    relations: List[Dict] = field(default_factory=list)
+    diagnostics: List[Dict] = field(default_factory=list)
+
+
+class Adapter:
+    name = "adapter"
+
+    def detect(self, codebase, files, manifests) -> int:
+        return 0
+
+    def parse_file(self, codebase, file_record, text) -> ParseResult:
+        return ParseResult()
+
+    def resolve_relations(self, codebase, symbols, relations):
+        return relations
+
+    def version(self) -> str:
+        return "0"
+
+    @property
+    def parser_id(self) -> str:
+        return f"{self.name}@{self.version()}"
+

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

@@ -0,0 +1,287 @@
+import re
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+from adapters.base import Adapter, ParseResult
+from core.schema import short_hash, stable_key
+
+
+LANGUAGE_BY_EXTENSION = {
+    ".py": "python",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".vue": "vue",
+    ".go": "go",
+    ".rs": "rust",
+    ".php": "php",
+    ".java": "java",
+    ".kt": "kotlin",
+    ".kts": "kotlin",
+    ".dart": "dart",
+    ".rb": "ruby",
+    ".swift": "swift",
+    ".sql": "sql",
+    ".sh": "shell",
+    ".md": "markdown",
+    ".json": "json",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".toml": "toml",
+    ".xml": "xml",
+}
+
+
+class GenericTextAdapter(Adapter):
+    name = "generic-text"
+
+    def detect(self, codebase, files, manifests) -> int:
+        return 1
+
+    def version(self) -> str:
+        return "1"
+
+    def parse_file(self, codebase, file_record, text) -> ParseResult:
+        path = file_record["path"]
+        language = file_record["language"]
+        content_hash = file_record["content_hash"]
+        file_symbol = _symbol(
+            codebase.name,
+            language,
+            "file",
+            Path(path).name,
+            path,
+            1,
+            max(1, len(text.splitlines())),
+            content_hash,
+            qualified_name=path,
+            parser=self.parser_id,
+        )
+        symbols = [file_symbol]
+        relations: List[Dict] = []
+        diagnostics: List[Dict] = []
+
+        extracted = self._extract_symbols(codebase.name, language, path, text, content_hash)
+        symbols.extend(extracted)
+        for symbol in extracted:
+            relations.append(
+                _relation(
+                    file_symbol["id"],
+                    "contains",
+                    path,
+                    symbol["line_start"],
+                    self.parser_id,
+                    confidence="exact",
+                    to_id=symbol["id"],
+                )
+            )
+
+        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"])
+            for target in _extract_imports(line, language):
+                relations.append(
+                    _relation(
+                        owner,
+                        "imports",
+                        path,
+                        lineno,
+                        self.parser_id,
+                        confidence="heuristic",
+                        to_external=f"import:{target}",
+                    )
+                )
+            for target in _extract_calls(line):
+                relations.append(
+                    _relation(
+                        owner,
+                        "calls",
+                        path,
+                        lineno,
+                        self.parser_id,
+                        confidence="heuristic",
+                        to_external=f"call:{target}",
+                    )
+                )
+            for relation_type, external in _extract_resources(line):
+                relations.append(
+                    _relation(
+                        owner,
+                        relation_type,
+                        path,
+                        lineno,
+                        self.parser_id,
+                        confidence="heuristic",
+                        to_external=external,
+                    )
+                )
+
+        if not extracted and language not in {"json", "yaml", "toml", "markdown", "xml"}:
+            diagnostics.append(
+                {
+                    "codebase": codebase.name,
+                    "path": path,
+                    "line": 1,
+                    "severity": "info",
+                    "kind": "low_confidence",
+                    "message": "generic-text adapter found no structural symbols",
+                    "parser": self.parser_id,
+                }
+            )
+
+        return ParseResult(symbols=symbols, relations=relations, diagnostics=diagnostics)
+
+    def _extract_symbols(self, codebase: str, language: str, path: str, text: str, content_hash: str) -> List[Dict]:
+        symbols: List[Dict] = []
+        seen: Dict[str, int] = {}
+        lines = text.splitlines()
+        for lineno, line in enumerate(lines, start=1):
+            matches = _symbol_matches(line, language)
+            for kind, name, signature in matches:
+                base = f"{path}:{kind}:{name}:{signature}"
+                seen[base] = seen.get(base, 0) + 1
+                suffix = "" if seen[base] == 1 else f":{seen[base]}"
+                symbols.append(
+                    _symbol(
+                        codebase,
+                        language,
+                        kind,
+                        name,
+                        path,
+                        lineno,
+                        lineno,
+                        content_hash,
+                        qualified_name=f"{path}::{name}{suffix}",
+                        signature=signature.strip()[:500],
+                        parser=self.parser_id,
+                    )
+                )
+        for index, symbol in enumerate(symbols):
+            next_start = symbols[index + 1]["line_start"] if index + 1 < len(symbols) else len(lines) + 1
+            symbol["line_end"] = max(symbol["line_start"], next_start - 1)
+        return symbols
+
+
+def language_for_path(path: Path) -> str:
+    return LANGUAGE_BY_EXTENSION.get(path.suffix.lower(), path.suffix.lower().lstrip(".") or "text")
+
+
+def _symbol_matches(line: str, language: str) -> List[Tuple[str, str, str]]:
+    stripped = line.strip()
+    patterns = [
+        ("class", r"\bclass\s+([A-Za-z_][A-Za-z0-9_]*)"),
+        ("interface", r"\binterface\s+([A-Za-z_][A-Za-z0-9_]*)"),
+        ("trait", r"\btrait\s+([A-Za-z_][A-Za-z0-9_]*)"),
+        ("struct", r"\bstruct\s+([A-Za-z_][A-Za-z0-9_]*)"),
+        ("function", r"\bfunction\s+([A-Za-z_][A-Za-z0-9_]*)\s*\("),
+        ("function", r"\bdef\s+([A-Za-z_][A-Za-z0-9_]*)\s*\("),
+        ("function", r"\bfunc\s+(?:\([^)]+\)\s*)?([A-Za-z_][A-Za-z0-9_]*)\s*\("),
+        ("function", r"\bfn\s+([A-Za-z_][A-Za-z0-9_]*)\s*\("),
+        ("function", r"\b(?:const|let|var)\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(?:async\s*)?\([^)]*\)\s*=>"),
+        ("function", r"\b(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_][A-Za-z0-9_]*)\s*\("),
+        ("method", r"^\s*(?:public|protected|private|static|async|override|final|\s)+\s*([A-Za-z_][A-Za-z0-9_]*)\s*\([^;]*\)\s*(?:\{|=>)"),
+    ]
+    result: List[Tuple[str, str, str]] = []
+    for kind, pattern in patterns:
+        match = re.search(pattern, stripped)
+        if match:
+            name = match.group(1)
+            if name in {"if", "for", "while", "switch", "catch", "return"}:
+                continue
+            adjusted_kind = "test" if name.lower().startswith("test") else kind
+            result.append((adjusted_kind, name, stripped))
+    return result
+
+
+def _extract_imports(line: str, language: str) -> List[str]:
+    patterns = [
+        r"^\s*import\s+(?:.+?\s+from\s+)?['\"]([^'\"]+)['\"]",
+        r"^\s*from\s+([A-Za-z0-9_.]+)\s+import\s+",
+        r"^\s*import\s+([A-Za-z0-9_./-]+)",
+        r"^\s*use\s+([^;]+);",
+        r"^\s*require(?:_once)?\s*\(?['\"]([^'\"]+)['\"]",
+        r"^\s*include(?:_once)?\s*\(?['\"]([^'\"]+)['\"]",
+        r"^\s*package\s+([A-Za-z0-9_.]+)",
+    ]
+    result = []
+    for pattern in patterns:
+        match = re.search(pattern, line)
+        if match:
+            result.append(match.group(1).strip())
+    return result
+
+
+def _extract_calls(line: str) -> List[str]:
+    if line.strip().startswith(("#", "//", "*", "/*")):
+        return []
+    result = []
+    for match in re.finditer(r"\b([A-Za-z_][A-Za-z0-9_]*)\s*\(", line):
+        name = match.group(1)
+        if name in {"if", "for", "while", "switch", "catch", "function", "return", "sizeof"}:
+            continue
+        result.append(name)
+    return result[:20]
+
+
+def _extract_resources(line: str) -> List[Tuple[str, str]]:
+    lowered = line.lower()
+    result: List[Tuple[str, str]] = []
+    for pattern in [r"\bfrom\s+[`\"]?([A-Za-z0-9_.-]+)", r"\bjoin\s+[`\"]?([A-Za-z0-9_.-]+)"]:
+        for match in re.finditer(pattern, lowered):
+            result.append(("reads", f"table:{match.group(1)}"))
+    for pattern in [r"\binsert\s+into\s+[`\"]?([A-Za-z0-9_.-]+)", r"\bupdate\s+[`\"]?([A-Za-z0-9_.-]+)", r"\bdelete\s+from\s+[`\"]?([A-Za-z0-9_.-]+)"]:
+        for match in re.finditer(pattern, lowered):
+            result.append(("writes", f"table:{match.group(1)}"))
+    for match in re.finditer(r"\b(?:process\.env\.|env\(|getenv\(|os\.environ(?:\.get)?\(|System\.getenv\()\s*['\"]?([A-Za-z_][A-Za-z0-9_]*)", line):
+        result.append(("config_uses", f"env:{match.group(1)}"))
+    for match in re.finditer(r"https?://[A-Za-z0-9_./:%?#=&+-]+", line):
+        result.append(("calls", f"url:{match.group(0)}"))
+    return result[:20]
+
+
+def _symbol(codebase, language, kind, name, path, line_start, line_end, content_hash, qualified_name="", signature="", parser="", visibility=""):
+    qualified = qualified_name or f"{path}::{name}"
+    key = stable_key(f"{qualified}:{signature}") if signature else stable_key(qualified)
+    return {
+        "id": f"{language}:{codebase}:{key}:{short_hash(qualified + signature)}",
+        "codebase": codebase,
+        "kind": kind,
+        "name": name,
+        "qualified_name": qualified,
+        "container_id": "",
+        "path": path,
+        "line_start": line_start,
+        "line_end": line_end,
+        "signature": signature,
+        "language": language,
+        "content_hash": content_hash,
+        "visibility": visibility,
+        "metadata": {"parser": parser} if parser else {},
+    }
+
+
+def _relation(from_id, relation_type, path, line, parser, confidence, to_id="", to_external="", metadata=None):
+    return {
+        "from_id": from_id,
+        "relation_type": relation_type,
+        "to_id": to_id,
+        "to_external": to_external,
+        "evidence_path": path,
+        "evidence_line": line,
+        "confidence": confidence,
+        "parser": parser,
+        "metadata": metadata or {},
+    }
+
+
+def _line_ranges(symbols: List[Dict]):
+    return [(symbol["line_start"], symbol["line_end"], symbol["id"]) for symbol in symbols]
+
+
+def _owner_for_line(ranges, line, fallback):
+    for start, end, symbol_id in ranges:
+        if start <= line <= end:
+            return symbol_id
+    return fallback
+

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

@@ -0,0 +1,17 @@
+from .generic_text import GenericTextAdapter
+
+
+class AdapterRegistry:
+    def __init__(self):
+        self.adapters = [GenericTextAdapter()]
+
+    def adapters_for(self, codebase, files, manifests):
+        scored = []
+        for adapter in self.adapters:
+            score = adapter.detect(codebase, files, manifests)
+            if score > 0:
+                scored.append((score, adapter))
+        if not scored:
+            return [GenericTextAdapter()]
+        return [adapter for _, adapter in sorted(scored, key=lambda item: item[0], reverse=True)]
+