graphifyy 0.3.4__tar.gz → 0.3.6__tar.gz

{graphifyy-0.3.4 → graphifyy-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphifyy
-Version: 0.3.4
+Version: 0.3.6
 Summary: AI coding assistant skill (Claude Code, Codex, OpenCode, OpenClaw) - turn any folder of code, docs, papers, or images into a queryable knowledge graph
 License: MIT License
         
@@ -50,6 +50,7 @@ Requires-Dist: tree-sitter-swift
 Requires-Dist: tree-sitter-lua
 Requires-Dist: tree-sitter-zig
 Requires-Dist: tree-sitter-powershell
+Requires-Dist: tree-sitter-elixir
 Provides-Extra: mcp
 Requires-Dist: mcp; extra == "mcp"
 Provides-Extra: neo4j
@@ -61,6 +62,9 @@ Provides-Extra: watch
 Requires-Dist: watchdog; extra == "watch"
 Provides-Extra: leiden
 Requires-Dist: graspologic; extra == "leiden"
+Provides-Extra: office
+Requires-Dist: python-docx; extra == "office"
+Requires-Dist: openpyxl; extra == "office"
 Provides-Extra: all
 Requires-Dist: mcp; extra == "all"
 Requires-Dist: neo4j; extra == "all"
@@ -68,6 +72,8 @@ Requires-Dist: pypdf; extra == "all"
 Requires-Dist: html2text; extra == "all"
 Requires-Dist: watchdog; extra == "all"
 Requires-Dist: graspologic; extra == "all"
+Requires-Dist: python-docx; extra == "all"
+Requires-Dist: openpyxl; extra == "all"
 Dynamic: license-file
 
 # graphify
@@ -239,6 +245,7 @@ Works with any mix of file types:
 |------|-----------|------------|
 | Code | `.py .ts .js .go .rs .java .c .cpp .rb .cs .kt .scala .php .swift .lua .zig .ps1` | AST via tree-sitter + call-graph + docstring/comment rationale |
 | Docs | `.md .txt .rst` | Concepts + relationships + design rationale via Claude |
+| Office | `.docx .xlsx` | Converted to markdown then extracted via Claude (requires `pip install graphifyy[office]`) |
 | Papers | `.pdf` | Citation mining + concept extraction |
 | Images | `.png .jpg .webp .gif` | Claude vision - screenshots, diagrams, any language |
 

{graphifyy-0.3.4 → graphifyy-0.3.6}/README.md

@@ -167,6 +167,7 @@ Works with any mix of file types:
 |------|-----------|------------|
 | Code | `.py .ts .js .go .rs .java .c .cpp .rb .cs .kt .scala .php .swift .lua .zig .ps1` | AST via tree-sitter + call-graph + docstring/comment rationale |
 | Docs | `.md .txt .rst` | Concepts + relationships + design rationale via Claude |
+| Office | `.docx .xlsx` | Converted to markdown then extracted via Claude (requires `pip install graphifyy[office]`) |
 | Papers | `.pdf` | Citation mining + concept extraction |
 | Images | `.png .jpg .webp .gif` | Claude vision - screenshots, diagrams, any language |
 

{graphifyy-0.3.4 → graphifyy-0.3.6}/graphify/detect.py

@@ -17,10 +17,11 @@ class FileType(str, Enum):
 
 _MANIFEST_PATH = "graphify-out/manifest.json"
 
-CODE_EXTENSIONS = {'.py', '.ts', '.js', '.tsx', '.go', '.rs', '.java', '.cpp', '.cc', '.cxx', '.c', '.h', '.hpp', '.rb', '.swift', '.kt', '.kts', '.cs', '.scala', '.php', '.lua', '.toc', '.zig', '.ps1'}
+CODE_EXTENSIONS = {'.py', '.ts', '.js', '.tsx', '.go', '.rs', '.java', '.cpp', '.cc', '.cxx', '.c', '.h', '.hpp', '.rb', '.swift', '.kt', '.kts', '.cs', '.scala', '.php', '.lua', '.toc', '.zig', '.ps1', '.ex', '.exs'}
 DOC_EXTENSIONS = {'.md', '.txt', '.rst'}
 PAPER_EXTENSIONS = {'.pdf'}
 IMAGE_EXTENSIONS = {'.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg'}
+OFFICE_EXTENSIONS = {'.docx', '.xlsx'}
 
 CORPUS_WARN_THRESHOLD = 50_000    # words - below this, warn "you may not need a graph"
 CORPUS_UPPER_THRESHOLD = 500_000  # words - above this, warn about token cost
@@ -86,6 +87,8 @@ def classify_file(path: Path) -> FileType | None:
         if _looks_like_paper(path):
             return FileType.PAPER
         return FileType.DOCUMENT
+    if ext in OFFICE_EXTENSIONS:
+        return FileType.DOCUMENT
     return None
 
 
@@ -104,10 +107,115 @@ def extract_pdf_text(path: Path) -> str:
         return ""
 
 
+def docx_to_markdown(path: Path) -> str:
+    """Convert a .docx file to markdown text using python-docx."""
+    try:
+        from docx import Document
+        from docx.oxml.ns import qn
+        doc = Document(str(path))
+        lines = []
+        for para in doc.paragraphs:
+            style = para.style.name if para.style else ""
+            text = para.text.strip()
+            if not text:
+                lines.append("")
+                continue
+            if style.startswith("Heading 1"):
+                lines.append(f"# {text}")
+            elif style.startswith("Heading 2"):
+                lines.append(f"## {text}")
+            elif style.startswith("Heading 3"):
+                lines.append(f"### {text}")
+            elif style.startswith("List"):
+                lines.append(f"- {text}")
+            else:
+                lines.append(text)
+        # Tables
+        for table in doc.tables:
+            rows = [[cell.text.strip() for cell in row.cells] for row in table.rows]
+            if not rows:
+                continue
+            header = "| " + " | ".join(rows[0]) + " |"
+            sep = "| " + " | ".join("---" for _ in rows[0]) + " |"
+            lines.extend([header, sep])
+            for row in rows[1:]:
+                lines.append("| " + " | ".join(row) + " |")
+        return "\n".join(lines)
+    except ImportError:
+        return ""
+    except Exception:
+        return ""
+
+
+def xlsx_to_markdown(path: Path) -> str:
+    """Convert an .xlsx file to markdown text using openpyxl."""
+    try:
+        import openpyxl
+        wb = openpyxl.load_workbook(str(path), read_only=True, data_only=True)
+        sections = []
+        for sheet_name in wb.sheetnames:
+            ws = wb[sheet_name]
+            rows = []
+            for row in ws.iter_rows(values_only=True):
+                # Skip entirely empty rows
+                if all(cell is None for cell in row):
+                    continue
+                rows.append([str(cell) if cell is not None else "" for cell in row])
+            if not rows:
+                continue
+            sections.append(f"## Sheet: {sheet_name}")
+            if len(rows) >= 1:
+                header = "| " + " | ".join(rows[0]) + " |"
+                sep = "| " + " | ".join("---" for _ in rows[0]) + " |"
+                sections.extend([header, sep])
+                for row in rows[1:]:
+                    sections.append("| " + " | ".join(row) + " |")
+        wb.close()
+        return "\n".join(sections)
+    except ImportError:
+        return ""
+    except Exception:
+        return ""
+
+
+def convert_office_file(path: Path, out_dir: Path) -> Path | None:
+    """Convert a .docx or .xlsx to a markdown sidecar in out_dir.
+
+    Returns the path of the converted .md file, or None if conversion failed
+    or the required library is not installed.
+    """
+    ext = path.suffix.lower()
+    if ext == ".docx":
+        text = docx_to_markdown(path)
+    elif ext == ".xlsx":
+        text = xlsx_to_markdown(path)
+    else:
+        return None
+
+    if not text.strip():
+        return None
+
+    out_dir.mkdir(parents=True, exist_ok=True)
+    # Use a stable name derived from the original path to avoid collisions
+    import hashlib
+    name_hash = hashlib.sha256(str(path.resolve()).encode()).hexdigest()[:8]
+    out_path = out_dir / f"{path.stem}_{name_hash}.md"
+    out_path.write_text(
+        f"<!-- converted from {path.name} -->\n\n{text}",
+        encoding="utf-8",
+    )
+    return out_path
+
+
 def count_words(path: Path) -> int:
     try:
-        if path.suffix.lower() == ".pdf":
+        ext = path.suffix.lower()
+        if ext == ".pdf":
             return len(extract_pdf_text(path).split())
+        if ext == ".docx":
+            return len(docx_to_markdown(path).split())
+        if ext == ".xlsx":
+            return len(xlsx_to_markdown(path).split())
         return len(path.read_text(errors="ignore").split())
     except Exception:
         return 0
@@ -224,6 +332,8 @@ def detect(root: Path) -> dict:
                     seen.add(p)
                     all_files.append(p)
 
+    converted_dir = root / "graphify-out" / "converted"
+
     for p in all_files:
         # For memory dir files, skip hidden/noise filtering
         in_memory = memory_dir.exists() and str(p).startswith(str(memory_dir))
@@ -232,6 +342,9 @@ def detect(root: Path) -> dict:
             # but catch hidden files at the root level
             if p.name.startswith("."):
                 continue
+            # Skip files inside our own converted/ dir (avoid re-processing sidecars)
+            if str(p).startswith(str(converted_dir)):
+                continue
         if _is_ignored(p, root, ignore_patterns):
             continue
         if _is_sensitive(p):
@@ -239,6 +352,16 @@ def detect(root: Path) -> dict:
             continue
         ftype = classify_file(p)
         if ftype:
+            # Office files: convert to markdown sidecar so subagents can read them
+            if p.suffix.lower() in OFFICE_EXTENSIONS:
+                md_path = convert_office_file(p, converted_dir)
+                if md_path:
+                    files[ftype].append(str(md_path))
+                    total_words += count_words(md_path)
+                else:
+                    # Conversion failed (library not installed) - skip with note
+                    skipped_sensitive.append(str(p) + " [office conversion failed - pip install graphifyy[office]]")
+                continue
             files[ftype].append(str(p))
             total_words += count_words(p)
 

{graphifyy-0.3.4 → graphifyy-0.3.6}/graphify/extract.py

@@ -1928,6 +1928,183 @@ def _resolve_cross_file_imports(
     return new_edges
 
 
+def extract_elixir(path: Path) -> dict:
+    """Extract modules, functions, imports, and calls from a .ex/.exs file."""
+    try:
+        import tree_sitter_elixir as tselixir
+        from tree_sitter import Language, Parser
+    except ImportError:
+        return {"nodes": [], "edges": [], "error": "tree_sitter_elixir not installed"}
+
+    try:
+        language = Language(tselixir.language())
+        parser = Parser(language)
+        source = path.read_bytes()
+        tree = parser.parse(source)
+        root = tree.root_node
+    except Exception as e:
+        return {"nodes": [], "edges": [], "error": str(e)}
+
+    stem = path.stem
+    str_path = str(path)
+    nodes: list[dict] = []
+    edges: list[dict] = []
+    seen_ids: set[str] = set()
+    function_bodies: list[tuple[str, Any]] = []
+
+    def add_node(nid: str, label: str, line: int) -> None:
+        if nid not in seen_ids:
+            seen_ids.add(nid)
+            nodes.append({"id": nid, "label": label, "file_type": "code",
+                          "source_file": str_path, "source_location": f"L{line}"})
+
+    def add_edge(src: str, tgt: str, relation: str, line: int,
+                 confidence: str = "EXTRACTED", weight: float = 1.0) -> None:
+        edges.append({"source": src, "target": tgt, "relation": relation,
+                      "confidence": confidence, "source_file": str_path,
+                      "source_location": f"L{line}", "weight": weight})
+
+    file_nid = _make_id(stem)
+    add_node(file_nid, path.name, 1)
+
+    _IMPORT_KEYWORDS = frozenset({"alias", "import", "require", "use"})
+
+    def _get_alias_text(node) -> str | None:
+        for child in node.children:
+            if child.type == "alias":
+                return source[child.start_byte:child.end_byte].decode("utf-8", errors="replace")
+        return None
+
+    def walk(node, parent_module_nid: str | None = None) -> None:
+        if node.type != "call":
+            for child in node.children:
+                walk(child, parent_module_nid)
+            return
+
+        identifier_node = None
+        arguments_node = None
+        do_block_node = None
+        for child in node.children:
+            if child.type == "identifier":
+                identifier_node = child
+            elif child.type == "arguments":
+                arguments_node = child
+            elif child.type == "do_block":
+                do_block_node = child
+
+        if identifier_node is None:
+            for child in node.children:
+                walk(child, parent_module_nid)
+            return
+
+        keyword = source[identifier_node.start_byte:identifier_node.end_byte].decode("utf-8", errors="replace")
+        line = node.start_point[0] + 1
+
+        if keyword == "defmodule":
+            module_name = _get_alias_text(arguments_node) if arguments_node else None
+            if not module_name:
+                return
+            module_nid = _make_id(stem, module_name)
+            add_node(module_nid, module_name, line)
+            add_edge(file_nid, module_nid, "contains", line)
+            if do_block_node:
+                for child in do_block_node.children:
+                    walk(child, parent_module_nid=module_nid)
+            return
+
+        if keyword in ("def", "defp"):
+            func_name = None
+            if arguments_node:
+                for child in arguments_node.children:
+                    if child.type == "call":
+                        for sub in child.children:
+                            if sub.type == "identifier":
+                                func_name = source[sub.start_byte:sub.end_byte].decode("utf-8", errors="replace")
+                                break
+                    elif child.type == "identifier":
+                        func_name = source[child.start_byte:child.end_byte].decode("utf-8", errors="replace")
+                        break
+            if not func_name:
+                return
+            container = parent_module_nid or file_nid
+            func_nid = _make_id(container, func_name)
+            add_node(func_nid, f"{func_name}()", line)
+            if parent_module_nid:
+                add_edge(parent_module_nid, func_nid, "method", line)
+            else:
+                add_edge(file_nid, func_nid, "contains", line)
+            if do_block_node:
+                function_bodies.append((func_nid, do_block_node))
+            return
+
+        if keyword in _IMPORT_KEYWORDS and arguments_node:
+            module_name = _get_alias_text(arguments_node)
+            if module_name:
+                tgt_nid = _make_id(module_name)
+                add_edge(file_nid, tgt_nid, "imports", line)
+            return
+
+        for child in node.children:
+            walk(child, parent_module_nid)
+
+    walk(root)
+
+    label_to_nid: dict[str, str] = {}
+    for n in nodes:
+        normalised = n["label"].strip("()").lstrip(".")
+        label_to_nid[normalised.lower()] = n["id"]
+
+    seen_call_pairs: set[tuple[str, str]] = set()
+    _SKIP_KEYWORDS = frozenset({
+        "def", "defp", "defmodule", "defmacro", "defmacrop",
+        "defstruct", "defprotocol", "defimpl", "defguard",
+        "alias", "import", "require", "use",
+        "if", "unless", "case", "cond", "with", "for",
+    })
+
+    def walk_calls(node, caller_nid: str) -> None:
+        if node.type != "call":
+            for child in node.children:
+                walk_calls(child, caller_nid)
+            return
+        for child in node.children:
+            if child.type == "identifier":
+                kw = source[child.start_byte:child.end_byte].decode("utf-8", errors="replace")
+                if kw in _SKIP_KEYWORDS:
+                    for c in node.children:
+                        walk_calls(c, caller_nid)
+                    return
+                break
+        callee_name: str | None = None
+        for child in node.children:
+            if child.type == "dot":
+                dot_text = source[child.start_byte:child.end_byte].decode("utf-8", errors="replace")
+                parts = dot_text.rstrip(".").split(".")
+                if parts:
+                    callee_name = parts[-1]
+                break
+            if child.type == "identifier":
+                callee_name = source[child.start_byte:child.end_byte].decode("utf-8", errors="replace")
+                break
+        if callee_name:
+            tgt_nid = label_to_nid.get(callee_name.lower())
+            if tgt_nid and tgt_nid != caller_nid:
+                pair = (caller_nid, tgt_nid)
+                if pair not in seen_call_pairs:
+                    seen_call_pairs.add(pair)
+                    add_edge(caller_nid, tgt_nid, "calls",
+                             node.start_point[0] + 1, confidence="INFERRED", weight=0.8)
+        for child in node.children:
+            walk_calls(child, caller_nid)
+
+    for caller_nid, body in function_bodies:
+        walk_calls(body, caller_nid)
+
+    clean_edges = [e for e in edges if e["source"] in seen_ids and
+                   (e["target"] in seen_ids or e["relation"] == "imports")]
+    return {"nodes": nodes, "edges": clean_edges, "input_tokens": 0, "output_tokens": 0}
+
+
 # ── Main extract and collect_files ────────────────────────────────────────────
 
 def extract(paths: list[Path]) -> dict:
@@ -1980,6 +2157,8 @@ def extract(paths: list[Path]) -> dict:
         ".toc": extract_lua,
         ".zig": extract_zig,
         ".ps1": extract_powershell,
+        ".ex": extract_elixir,
+        ".exs": extract_elixir,
     }
 
     for path in paths:

{graphifyy-0.3.4 → graphifyy-0.3.6}/graphifyy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphifyy
-Version: 0.3.4
+Version: 0.3.6
 Summary: AI coding assistant skill (Claude Code, Codex, OpenCode, OpenClaw) - turn any folder of code, docs, papers, or images into a queryable knowledge graph
 License: MIT License
         
@@ -50,6 +50,7 @@ Requires-Dist: tree-sitter-swift
 Requires-Dist: tree-sitter-lua
 Requires-Dist: tree-sitter-zig
 Requires-Dist: tree-sitter-powershell
+Requires-Dist: tree-sitter-elixir
 Provides-Extra: mcp
 Requires-Dist: mcp; extra == "mcp"
 Provides-Extra: neo4j
@@ -61,6 +62,9 @@ Provides-Extra: watch
 Requires-Dist: watchdog; extra == "watch"
 Provides-Extra: leiden
 Requires-Dist: graspologic; extra == "leiden"
+Provides-Extra: office
+Requires-Dist: python-docx; extra == "office"
+Requires-Dist: openpyxl; extra == "office"
 Provides-Extra: all
 Requires-Dist: mcp; extra == "all"
 Requires-Dist: neo4j; extra == "all"
@@ -68,6 +72,8 @@ Requires-Dist: pypdf; extra == "all"
 Requires-Dist: html2text; extra == "all"
 Requires-Dist: watchdog; extra == "all"
 Requires-Dist: graspologic; extra == "all"
+Requires-Dist: python-docx; extra == "all"
+Requires-Dist: openpyxl; extra == "all"
 Dynamic: license-file
 
 # graphify
@@ -239,6 +245,7 @@ Works with any mix of file types:
 |------|-----------|------------|
 | Code | `.py .ts .js .go .rs .java .c .cpp .rb .cs .kt .scala .php .swift .lua .zig .ps1` | AST via tree-sitter + call-graph + docstring/comment rationale |
 | Docs | `.md .txt .rst` | Concepts + relationships + design rationale via Claude |
+| Office | `.docx .xlsx` | Converted to markdown then extracted via Claude (requires `pip install graphifyy[office]`) |
 | Papers | `.pdf` | Citation mining + concept extraction |
 | Images | `.png .jpg .webp .gif` | Claude vision - screenshots, diagrams, any language |
 

{graphifyy-0.3.4 → graphifyy-0.3.6}/graphifyy.egg-info/requires.txt

@@ -17,6 +17,7 @@ tree-sitter-swift
 tree-sitter-lua
 tree-sitter-zig
 tree-sitter-powershell
+tree-sitter-elixir
 
 [all]
 mcp
@@ -25,6 +26,8 @@ pypdf
 html2text
 watchdog
 graspologic
+python-docx
+openpyxl
 
 [leiden]
 graspologic
@@ -35,6 +38,10 @@ mcp
 [neo4j]
 neo4j
 
+[office]
+python-docx
+openpyxl
+
 [pdf]
 pypdf
 html2text

{graphifyy-0.3.4 → graphifyy-0.3.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graphifyy"
-version = "0.3.4"
+version = "0.3.6"
 description = "AI coding assistant skill (Claude Code, Codex, OpenCode, OpenClaw) - turn any folder of code, docs, papers, or images into a queryable knowledge graph"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -30,6 +30,7 @@ dependencies = [
     "tree-sitter-lua",
     "tree-sitter-zig",
     "tree-sitter-powershell",
+    "tree-sitter-elixir",
 ]
 
 [project.urls]
@@ -43,7 +44,8 @@ neo4j = ["neo4j"]
 pdf = ["pypdf", "html2text"]
 watch = ["watchdog"]
 leiden = ["graspologic"]
-all = ["mcp", "neo4j", "pypdf", "html2text", "watchdog", "graspologic"]
+office = ["python-docx", "openpyxl"]
+all = ["mcp", "neo4j", "pypdf", "html2text", "watchdog", "graspologic", "python-docx", "openpyxl"]
 
 [project.scripts]
 graphify = "graphify.__main__:main"

{graphifyy-0.3.4 → graphifyy-0.3.6}/tests/test_extract.py

@@ -61,7 +61,7 @@ def test_collect_files_from_dir():
     supported = {".py", ".js", ".ts", ".tsx", ".go", ".rs",
                  ".java", ".c", ".cpp", ".cc", ".cxx", ".rb",
                  ".cs", ".kt", ".kts", ".scala", ".php", ".h", ".hpp",
-                 ".swift", ".lua", ".toc", ".zig", ".ps1"}
+                 ".swift", ".lua", ".toc", ".zig", ".ps1", ".ex", ".exs"}
     assert all(f.suffix in supported for f in files)
     assert len(files) > 0
 

{graphifyy-0.3.4 → graphifyy-0.3.6}/tests/test_languages.py

@@ -337,3 +337,37 @@ def test_swift_emits_calls():
     r = extract_swift(FIXTURES / "sample.swift")
     calls = _calls(r)
     assert any("process" in src and "validate" in tgt for src, tgt in calls)
+
+
+# ── Elixir ────────────────────────────────────────────────────────────────────
+
+from graphify.extract import extract_elixir
+
+def test_elixir_finds_module():
+    r = extract_elixir(FIXTURES / "sample.ex")
+    assert "error" not in r
+    labels = [n["label"] for n in r["nodes"]]
+    assert any("MyApp.Accounts.User" in l for l in labels)
+
+def test_elixir_finds_functions():
+    r = extract_elixir(FIXTURES / "sample.ex")
+    labels = [n["label"] for n in r["nodes"]]
+    assert any("create" in l for l in labels)
+    assert any("find" in l for l in labels)
+    assert any("validate" in l for l in labels)
+
+def test_elixir_finds_imports():
+    r = extract_elixir(FIXTURES / "sample.ex")
+    import_edges = [e for e in r["edges"] if e["relation"] == "imports"]
+    assert len(import_edges) >= 2
+
+def test_elixir_finds_calls():
+    r = extract_elixir(FIXTURES / "sample.ex")
+    calls = {(e["source"], e["target"]) for e in r["edges"] if e["relation"] == "calls"}
+    labels = {n["id"]: n["label"] for n in r["nodes"]}
+    assert any("create" in labels.get(src, "") and "validate" in labels.get(tgt, "") for src, tgt in calls)
+
+def test_elixir_method_edges():
+    r = extract_elixir(FIXTURES / "sample.ex")
+    methods = [e for e in r["edges"] if e["relation"] == "method"]
+    assert len(methods) >= 3