phi47-superpowers 0.1.0__py3-none-any.whl

phi47/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2025 wcalmels -- TUCH Systems Research Laboratory
+# SPDX-License-Identifier: MIT
+__version__   = "0.1.0"
+__author__    = "wcalmels"
+__email__     = "wcalmels@phi47.cl"
+__license__   = "MIT"
+__copyright__ = "Copyright (c) 2025 TUCH Systems Research Laboratory"
+
+from phi47.linter.phi_linter   import Phi47Linter
+from phi47.wrapper.llm_wrapper import Phi47LLMWrapper
+from phi47.core.phi_calculator import PhiCalculator
+
+__all__ = ["Phi47Linter", "Phi47LLMWrapper", "PhiCalculator"]

phi47/cli/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (c) 2025 wcalmels -- TUCH Systems Research Laboratory
+# SPDX-License-Identifier: MIT

phi47/cli/main.py

@@ -0,0 +1,102 @@
+# Copyright (c) 2025 wcalmels -- TUCH Systems Research Laboratory
+# SPDX-License-Identifier: MIT
+from __future__ import annotations
+import json
+from pathlib import Path
+import click
+from rich.console import Console
+from rich.table   import Table
+from phi47.linter.phi_linter   import Phi47Linter
+from phi47.wrapper.llm_wrapper import Phi47LLMWrapper
+
+console = Console()
+
+
+@click.group()
+@click.version_option("0.1.0", prog_name="phi47")
+def cli():
+    """phi47 -- structural code quality layer based on IIT 4.0."""
+
+
+@cli.command()
+@click.argument("path", default=".")
+@click.option("--json", "as_json", is_flag=True, help="Output JSON")
+@click.option("--quiet", is_flag=True, help="Only show errors")
+def analyze(path, as_json, quiet):
+    """Analyze Phi of a file or directory."""
+    linter = Phi47Linter()
+    p = Path(path)
+    if p.is_file():
+        diags = linter.lint_file(str(p))
+        if as_json:
+            click.echo(json.dumps([d.to_dict() for d in diags], indent=2))
+            return
+        phi  = next((d.phi_value for d in diags if d.code == "P001"), 0.65)
+        icon = "G" if phi > 0.6 else "Y" if phi > 0.3 else "R"
+        console.print(f"[{icon}] {p.name}  Phi={phi:.3f}")
+        show = diags if not quiet else [d for d in diags if d.severity == "error"]
+        for d in show[:8]:
+            c = {"error":"red","warning":"yellow","info":"blue","hint":"dim"}.get(d.severity,"white")
+            console.print(f"  [{c}][{d.code}][/{c}] L{d.line}: {d.message}")
+            if not quiet:
+                console.print(f"    [dim]-> {d.suggestion}[/dim]")
+    else:
+        all_d = linter.lint_directory(str(p))
+        if as_json:
+            click.echo(json.dumps(
+                {fp: [d.to_dict() for d in ds] for fp, ds in all_d.items()}, indent=2))
+            return
+        import numpy as np
+        t = Table(title=f"Phi47: {p}")
+        t.add_column("File", style="cyan")
+        t.add_column("Phi",  justify="right")
+        t.add_column("E",    justify="right", style="red")
+        t.add_column("W",    justify="right", style="yellow")
+        phis = []
+        for fp, ds in sorted(all_d.items()):
+            phi = next((d.phi_value for d in ds if d.code == "P001"), 0.65)
+            phis.append(phi)
+            e = sum(1 for d in ds if d.severity == "error")
+            w = sum(1 for d in ds if d.severity == "warning")
+            t.add_row(Path(fp).name, f"{phi:.3f}", str(e), str(w))
+        console.print(t)
+        if phis:
+            console.print(f"System Phi = {float(np.mean(phis)):.3f}")
+
+
+@cli.command()
+@click.argument("task")
+@click.option("--output", "-o", default=None)
+@click.option("--backend", "-b", default="claude")
+@click.option("--threshold", default=0.5)
+def generate(task, output, backend, threshold):
+    """Generate code with Phi analysis and auto-refinement."""
+    console.print(f"[cyan]Task:[/cyan] {task}  [cyan]Backend:[/cyan] {backend}")
+    w = Phi47LLMWrapper(backend=backend, phi_threshold=threshold)
+    r = w.generate(task)
+    ok = "OK" if r["phi_ok"] else "!!"
+    console.print(f"[{ok}] Phi={r['phi']:.3f}  refinements={r['refinements']}")
+    if output:
+        Path(output).write_text(r["code"], encoding="utf-8")
+        console.print(f"Saved: {output}")
+    else:
+        click.echo(r["code"])
+    for s in r["suggestions"][:3]:
+        console.print(f"  -> {s}")
+
+
+@cli.command()
+@click.argument("path", default=".")
+def init(path):
+    """Initialize Phi47 in a project."""
+    p   = Path(path)
+    cfg = {"version": "0.1.0", "phi_threshold": 0.5,
+           "auto_refine": True, "backend": "claude"}
+    (p / ".phi47.json").write_text(json.dumps(cfg, indent=2), encoding="utf-8")
+    hook = p / ".git" / "hooks" / "pre-commit"
+    if hook.parent.exists():
+        hook.write_text("#!/bin/bash\nphi47 analyze . --quiet || exit 1\n", encoding="utf-8")
+        import stat
+        hook.chmod(hook.stat().st_mode | stat.S_IEXEC)
+        console.print("[green]Git hook installed[/green]")
+    console.print("[bold green]Phi47 initialized![/bold green] Run: phi47 analyze .")

phi47/core/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (c) 2025 wcalmels -- TUCH Systems Research Laboratory
+# SPDX-License-Identifier: MIT

phi47/core/phi_calculator.py

@@ -0,0 +1,67 @@
+# Copyright (c) 2025 wcalmels -- TUCH Systems Research Laboratory
+# SPDX-License-Identifier: MIT
+from __future__ import annotations
+import numpy as np
+from scipy import linalg
+
+
+class PhiCalculator:
+    """Calculates Phi for a connectivity matrix using spectral approximation (IIT 4.0).
+
+    Example::
+
+        calc = PhiCalculator()
+        import numpy as np
+        phi, meta = calc.calculate(np.random.rand(5, 5))
+        print(phi)
+    """
+
+    def calculate(self, connectivity: np.ndarray, method: str = "spectral") -> tuple:
+        """Calculate Phi.
+
+        Args:
+            connectivity: Square NxN float matrix.
+            method: 'spectral' (fast, O(n^3)) or 'exact' (n<=8 only).
+
+        Returns:
+            Tuple of (phi: float, metadata: dict).
+        """
+        if connectivity.ndim != 2 or connectivity.shape[0] != connectivity.shape[1]:
+            raise ValueError(f"Expected square matrix, got {connectivity.shape}")
+        m = (connectivity + connectivity.T) / 2.0
+        m = np.nan_to_num(m, nan=0.0)
+        if method == "exact" and m.shape[0] <= 8:
+            return self._exact(m)
+        return self._spectral(m)
+
+    def _spectral(self, m: np.ndarray) -> tuple:
+        cov  = m @ m.T
+        eigv = linalg.eigvalsh(cov)
+        eigv = eigv[eigv > 1e-10]
+        if not len(eigv):
+            return 0.0, {"method": "spectral", "phi": 0.0}
+        eigv /= eigv.sum()
+        h   = float(-np.sum(eigv * np.log2(eigv + 1e-12)))
+        k   = float(np.mean(np.abs(m)))
+        phi = h * (1.0 - np.exp(-k))
+        return float(phi), {"method": "spectral", "phi": phi,
+                            "total_information": h, "integration_factor": 1 - np.exp(-k)}
+
+    def _exact(self, m: np.ndarray) -> tuple:
+        from itertools import combinations
+        n       = m.shape[0]
+        all_idx = list(range(n))
+        min_phi = float("inf")
+        mip     = None
+        for k in range(1, n // 2 + 1):
+            for pa in combinations(all_idx, k):
+                pa = list(pa)
+                pb = [i for i in all_idx if i not in pa]
+                mi = max(0.0,
+                         np.linalg.norm(m[np.ix_(pa, pa)], "fro")
+                         + np.linalg.norm(m[np.ix_(pb, pb)], "fro")
+                         - np.linalg.norm(m, "fro"))
+                if mi < min_phi:
+                    min_phi, mip = mi, (pa, pb)
+        phi = float(min_phi) if min_phi != float("inf") else 0.0
+        return phi, {"method": "exact", "phi": phi, "mip": mip}

phi47/linter/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (c) 2025 wcalmels -- TUCH Systems Research Laboratory
+# SPDX-License-Identifier: MIT

phi47/linter/phi_linter.py

@@ -0,0 +1,177 @@
+# Copyright (c) 2025 wcalmels -- TUCH Systems Research Laboratory
+# SPDX-License-Identifier: MIT
+from __future__ import annotations
+import ast, json
+from dataclasses import dataclass, asdict
+from pathlib import Path
+import numpy as np
+from phi47.core.phi_calculator import PhiCalculator
+
+
+@dataclass(frozen=True)
+class Diagnostic:
+    file:       str
+    line:       int
+    col:        int
+    severity:   str
+    code:       str
+    message:    str
+    phi_value:  float
+    suggestion: str
+
+    def to_dict(self): return asdict(self)
+    def __str__(self):
+        return f"{self.file}:{self.line}:{self.col}: {self.severity} [{self.code}] {self.message}"
+
+
+class Phi47Linter:
+    """Phi-based linter compatible with any LSP editor.
+
+    Example::
+
+        linter = Phi47Linter()
+        for d in linter.lint_file("mycode.py"):
+            print(d)
+    """
+
+    def __init__(self, phi_error=0.3, phi_warning=0.5,
+                 complexity_error=15, complexity_warning=10, max_lines=80):
+        self.phi_error          = phi_error
+        self.phi_warning        = phi_warning
+        self.complexity_error   = complexity_error
+        self.complexity_warning = complexity_warning
+        self.max_lines          = max_lines
+        self._calc              = PhiCalculator()
+
+    def lint_file(self, filepath: str) -> list:
+        p = Path(filepath)
+        try:
+            tree = ast.parse(p.read_text(encoding="utf-8"), filename=str(p))
+        except SyntaxError as e:
+            return [Diagnostic(str(p), e.lineno or 1, 0, "error", "P000",
+                                f"Syntax: {e.msg}", 0.0, "Fix syntax first.")]
+        except OSError as e:
+            return [Diagnostic(str(p), 1, 0, "error", "P000",
+                                f"IO: {e}", 0.0, "Check permissions.")]
+        funcs  = _extract_functions(tree)
+        clss   = _extract_classes(tree)
+        matrix = _build_dep_matrix(funcs)
+        diags  = []
+        diags += self._check_phi(str(p), matrix)
+        diags += self._check_funcs(str(p), funcs)
+        diags += self._check_cd(str(p), matrix)
+        diags += self._check_classes(str(p), clss)
+        return sorted(diags, key=lambda d: (d.line, d.code))
+
+    def lint_directory(self, directory: str) -> dict:
+        skip = {".venv", "venv", "__pycache__", ".git", "dist", "build"}
+        out  = {}
+        for f in Path(directory).rglob("*.py"):
+            if any(p in skip for p in f.parts): continue
+            d = self.lint_file(str(f))
+            if d: out[str(f)] = d
+        return out
+
+    def lint_to_json(self, path: str) -> str:
+        if Path(path).is_dir():
+            data = {fp: [d.to_dict() for d in ds]
+                    for fp, ds in self.lint_directory(path).items()}
+        else:
+            data = {path: [d.to_dict() for d in self.lint_file(path)]}
+        return json.dumps(data, indent=2)
+
+    def _check_phi(self, fp, matrix):
+        if matrix.shape[0] < 2: return []
+        phi, _ = self._calc.calculate(matrix)
+        if phi < self.phi_error:
+            return [Diagnostic(fp, 1, 0, "error", "P001",
+                f"System Phi={phi:.3f} critically low (threshold {self.phi_error})",
+                phi, "Add connections between functions.")]
+        if phi < self.phi_warning:
+            return [Diagnostic(fp, 1, 0, "warning", "P001",
+                f"System Phi={phi:.3f} below recommended (threshold {self.phi_warning})",
+                phi, "Consider increasing causal connections.")]
+        return []
+
+    def _check_funcs(self, fp, funcs):
+        diags = []
+        for name, data in funcs.items():
+            calls   = set(data["calls"])
+            callers = {n for n, d in funcs.items() if name in d["calls"]}
+            cx, ln, lines = data["complexity"], data["lineno"], data["lines"]
+            if not calls and not callers and name not in {"main","__init__","__new__"}:
+                diags.append(Diagnostic(fp, ln, 0, "warning", "P002",
+                    f"Zombie function: '{name}' has no callers and no callees",
+                    0.0, f"Connect or remove '{name}'."))
+            if cx > self.complexity_error:
+                diags.append(Diagnostic(fp, ln, 0, "error", "P003",
+                    f"'{name}' complexity={cx} > {self.complexity_error}",
+                    0.0, "Decompose into smaller functions."))
+            elif cx > self.complexity_warning:
+                diags.append(Diagnostic(fp, ln, 0, "warning", "P003",
+                    f"'{name}' complexity={cx}", 0.0, "Consider splitting."))
+            if lines > self.max_lines:
+                diags.append(Diagnostic(fp, ln, 0, "hint", "P007",
+                    f"'{name}' is {lines} lines (limit {self.max_lines})",
+                    0.0, "Functions over 80 lines often have multiple responsibilities."))
+        return diags
+
+    def _check_cd(self, fp, matrix):
+        n = matrix.shape[0]
+        if n < 3: return []
+        cd = float(np.sum(matrix > 0) / (n * (n - 1) + 1e-10))
+        if cd < 0.05:
+            return [Diagnostic(fp, 1, 0, "info", "P004",
+                f"Low causal density={cd:.3f}: modules mostly isolated",
+                cd, "Consider a shared utility module.")]
+        return []
+
+    def _check_classes(self, fp, classes):
+        diags = []
+        for name, data in classes.items():
+            if not data["bases"] and not data["methods"]:
+                diags.append(Diagnostic(fp, data["lineno"], 0, "hint", "P006",
+                    f"Class '{name}' has no base class and no methods",
+                    0.0, "Consider @dataclass or adding methods."))
+        return diags
+
+
+def _extract_functions(tree):
+    funcs = {}
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef):
+            calls = []
+            for c in ast.walk(node):
+                if isinstance(c, ast.Call):
+                    if isinstance(c.func, ast.Name): calls.append(c.func.id)
+                    elif isinstance(c.func, ast.Attribute): calls.append(c.func.attr)
+            cx  = 1 + sum(1 for n in ast.walk(node)
+                          if isinstance(n, (ast.If, ast.For, ast.While,
+                                            ast.Try, ast.ExceptHandler)))
+            end = getattr(node, "end_lineno", node.lineno)
+            funcs[node.name] = {"calls": list(set(calls)), "complexity": cx,
+                                 "lineno": node.lineno, "lines": end - node.lineno}
+    return funcs
+
+
+def _extract_classes(tree):
+    out = {}
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef):
+            bases   = [b.id if isinstance(b, ast.Name) else "?" for b in node.bases]
+            methods = [n.name for n in ast.walk(node) if isinstance(n, ast.FunctionDef)]
+            out[node.name] = {"bases": bases, "methods": methods, "lineno": node.lineno}
+    return out
+
+
+def _build_dep_matrix(funcs):
+    names  = list(funcs.keys())
+    n      = len(names)
+    if n < 2: return np.zeros((2, 2))
+    idx    = {name: i for i, name in enumerate(names)}
+    matrix = np.zeros((n, n), dtype=float)
+    for name, data in funcs.items():
+        i = idx[name]
+        for c in data["calls"]:
+            if c in idx: matrix[i, idx[c]] = 1.0
+    return matrix

phi47/wrapper/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (c) 2025 wcalmels -- TUCH Systems Research Laboratory
+# SPDX-License-Identifier: MIT

phi47/wrapper/llm_wrapper.py

@@ -0,0 +1,105 @@
+# Copyright (c) 2025 wcalmels -- TUCH Systems Research Laboratory
+# SPDX-License-Identifier: MIT
+from __future__ import annotations
+import os
+from pathlib import Path
+from phi47.linter.phi_linter import Phi47Linter
+
+
+class Phi47LLMWrapper:
+    """Universal LLM wrapper that adds Phi analysis to generated code.
+
+    Supports Claude, GPT-4, and any chat-compatible API.
+    Caller keeps their own API key -- no markup, no vendor lock-in.
+
+    Example::
+
+        w = Phi47LLMWrapper(backend="claude")
+        r = w.generate("Build a binary search tree")
+        print(r["phi"], r["code"])
+    """
+
+    SYSTEM = ("You are an expert Python developer. Write clean code with high "
+              "causal cohesion. Include type hints and docstrings. "
+              "Return ONLY Python code, no explanation.")
+
+    def __init__(self, backend="claude", api_key=None,
+                 phi_threshold=0.5, auto_refine=True, max_refinements=2):
+        self.backend         = backend
+        self.api_key         = api_key or os.environ.get(
+            {"claude": "ANTHROPIC_API_KEY", "openai": "OPENAI_API_KEY"}.get(backend, ""), "")
+        self.phi_threshold   = phi_threshold
+        self.auto_refine     = auto_refine
+        self.max_refinements = max_refinements
+        self._linter         = Phi47Linter()
+        self._client         = None
+
+    def generate(self, task: str, context: str = "") -> dict:
+        """Generate code and run Phi analysis. Auto-refines if Phi < threshold."""
+        prompt = task if not context else f"{task}\n\nContext:\n{context}"
+        code   = self._extract(self._call(prompt))
+        phi, diags = self._phi_of(code)
+        refs = 0
+        if self.auto_refine and phi < self.phi_threshold:
+            for _ in range(self.max_refinements):
+                issues = "\n".join(f"- [{d.code}] {d.message}" for d in diags[:3])
+                code   = self._extract(self._call(
+                    f"Refactor for higher Phi.\nIssues:\n{issues}\n\n`python\n{code}\n`"))
+                phi, diags = self._phi_of(code)
+                refs += 1
+                if phi >= self.phi_threshold:
+                    break
+        return {
+            "code":        code,
+            "phi":         phi,
+            "phi_ok":      phi >= self.phi_threshold,
+            "diagnostics": [{"code": d.code, "message": d.message} for d in diags],
+            "suggestions": list({d.suggestion for d in diags})[:4],
+            "refinements": refs,
+            "backend":     self.backend,
+        }
+
+    def _call(self, prompt: str) -> str:
+        c = self._get_client()
+        if self.backend == "claude":
+            r = c.messages.create(
+                model="claude-sonnet-4-6", max_tokens=2048,
+                system=self.SYSTEM,
+                messages=[{"role": "user", "content": prompt}])
+            return r.content[0].text
+        if self.backend == "openai":
+            r = c.chat.completions.create(
+                model="gpt-4o", max_tokens=2048,
+                messages=[{"role": "system", "content": self.SYSTEM},
+                           {"role": "user",   "content": prompt}])
+            return r.choices[0].message.content
+        return f"# {prompt}\ndef solution(): pass\n"
+
+    def _get_client(self):
+        if self._client:
+            return self._client
+        if self.backend == "claude":
+            import anthropic
+            self._client = anthropic.Anthropic(api_key=self.api_key)
+        elif self.backend == "openai":
+            import openai
+            openai.api_key = self.api_key
+            self._client   = openai
+        return self._client
+
+    def _phi_of(self, code: str):
+        tmp = Path("_phi47_tmp.py")
+        try:
+            tmp.write_text(code, encoding="utf-8")
+            diags = self._linter.lint_file(str(tmp))
+            phi   = next((d.phi_value for d in diags if d.code == "P001"), 0.65)
+            return phi, diags
+        finally:
+            if tmp.exists():
+                tmp.unlink()
+
+    @staticmethod
+    def _extract(text: str) -> str:
+        if "`python" in text: return text.split("`python")[1].split("`")[0].strip()
+        if "`"       in text: return text.split("`")[1].split("`")[0].strip()
+        return text.strip()

phi47_superpowers-0.1.0.dist-info/METADATA

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: phi47-superpowers
+Version: 0.1.0
+Summary: Structural code quality layer based on IIT 4.0
+Author-email: wcalmels <wcalmels@phi47.cl>
+License: MIT License
+        
+        Copyright (c) 2025 wcalmels
+        TUCH Systems Research Laboratory -- Buenos Aires / Santiago
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in
+        all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+        THE SOFTWARE.
+        
+Project-URL: Homepage, https://phi47.tuch.systems
+Project-URL: Repository, https://github.com/wcalmels/phi47-superpowers
+Keywords: linter,code-quality,iit,phi,ast,developer-tools
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: scipy>=1.11
+Requires-Dist: click>=8.1
+Requires-Dist: rich>=13.0
+Provides-Extra: llm
+Requires-Dist: anthropic>=0.20; extra == "llm"
+Requires-Dist: openai>=1.0; extra == "llm"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4; extra == "dev"
+Requires-Dist: pytest-cov>=4.1; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: ruff>=0.1; extra == "dev"
+Dynamic: license-file
+
+# Phi47 Superpowers Layer
+
+[![CI](https://github.com/TUCHSystems/phi47-superpowers/actions/workflows/ci.yml/badge.svg)](https://github.com/TUCHSystems/phi47-superpowers/actions)
+[![PyPI](https://img.shields.io/pypi/v/phi47-superpowers)](https://pypi.org/project/phi47-superpowers/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+> Structural code quality layer based on Integrated Information Theory (IIT 4.0).
+> Works on top of any editor (VS Code, Cursor, Neovim) or LLM (Claude, GPT-4, Gemini).
+> No vendor lock-in. Use your own API keys.
+
+## Install
+
+    pip install phi47-superpowers
+    pip install "phi47-superpowers[llm]"
+
+## Quick start
+
+    phi47 analyze mycode.py
+    phi47 analyze .
+    phi47 generate "Build a REST API" --output api.py
+    phi47 init
+
+## Diagnostic codes
+
+| Code | Issue                     | Severity        |
+|------|---------------------------|-----------------|
+| P001 | Low system Phi            | error / warning |
+| P002 | Zombie function           | warning         |
+| P003 | High cyclomatic complexity| error / warning |
+| P004 | Low causal density        | info            |
+| P006 | Disconnected class        | hint            |
+| P007 | God function              | hint            |
+
+## Use as a library
+
+    from phi47 import Phi47Linter
+    linter = Phi47Linter()
+    for d in linter.lint_file("mycode.py"):
+        print(d)
+
+## Scientific background
+
+Phi47 applies spectral IIT 4.0 to dependency graphs:
+    Phi = H(eigenvalues(C*C^T)) * (1 - e^(-k))
+Runs in O(n^3) instead of exact O(2^n).
+
+## License
+
+MIT License -- Copyright (c) 2025 Walter Calmels Von dem Knesebeck
+TUCH Systems Research Laboratory

phi47_superpowers-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+phi47/__init__.py,sha256=IkrSV5JME5GAJP-fqXDqiiEKcO11Dk9WWAn56jtuozo,499
+phi47/cli/__init__.py,sha256=UUrV17MlE_BsxYvdVXHoNiUHzaBWVPn3TVLHPqB_-o4,100
+phi47/cli/main.py,sha256=fZKafJRXbRCFmiDoP2crXiePjDk51eSixmzjCd4NuqE,4069
+phi47/core/__init__.py,sha256=UUrV17MlE_BsxYvdVXHoNiUHzaBWVPn3TVLHPqB_-o4,100
+phi47/core/phi_calculator.py,sha256=XUKHhz3tBzdviWCoGGgpSOwuuATWWMg3TEh6TQfsay0,2500
+phi47/linter/__init__.py,sha256=UUrV17MlE_BsxYvdVXHoNiUHzaBWVPn3TVLHPqB_-o4,100
+phi47/linter/phi_linter.py,sha256=CVnOyO6cwhx26tSxEPdhsZa8vQ-WVnBZgf2q6nUYU08,7220
+phi47/wrapper/__init__.py,sha256=UUrV17MlE_BsxYvdVXHoNiUHzaBWVPn3TVLHPqB_-o4,100
+phi47/wrapper/llm_wrapper.py,sha256=HhepME-POnM8BnsFLVrWytY6NmLAzXPHIxFjhA02WSU,4242
+phi47_superpowers-0.1.0.dist-info/licenses/LICENSE,sha256=8pPQ3CTgxNqPcGHfkvjGC_CEuSfF1vEYZekvJwOljxk,1128
+phi47_superpowers-0.1.0.dist-info/METADATA,sha256=5QTnctUHof3Q012wrym-hz6Zs3b3XlHi6RWxdm4efxI,3857
+phi47_superpowers-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+phi47_superpowers-0.1.0.dist-info/entry_points.txt,sha256=V0nte5OpgHZmZ1cTw6ALD3TbiExJv3nyJamMZXZ8XVs,45
+phi47_superpowers-0.1.0.dist-info/top_level.txt,sha256=qb0JezuO_gAiSqkyrvadUUnXfldsCweaWqxeoa8iRvc,6
+phi47_superpowers-0.1.0.dist-info/RECORD,,

phi47_superpowers-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

phi47_superpowers-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+phi47 = phi47.cli.main:cli

phi47_superpowers-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 wcalmels
+TUCH Systems Research Laboratory -- Buenos Aires / Santiago
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

phi47_superpowers-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+phi47