specsmith 0.21.0.dev765__tar.gz → 0.21.0.dev774__tar.gz

{specsmith-0.21.0.dev765/src/specsmith.egg-info → specsmith-0.21.0.dev774}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specsmith
-Version: 0.21.0.dev765
+Version: 0.21.0.dev774
 Summary: AEE governance toolkit for AI-assisted development — session preflight gates, multi-agent dispatch, requirements↔test traceability, ESDB persistence, MCP server, and skills for Warp, Cursor, Claude Code, Copilot, Windsurf, and Aider.
 Author: Layer1Labs Silicon, Inc.
 License-Expression: MIT

{specsmith-0.21.0.dev765 → specsmith-0.21.0.dev774}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "specsmith"
-version = "0.21.0.dev765"
+version = "0.21.0.dev774"
 description = "AEE governance toolkit for AI-assisted development — session preflight gates, multi-agent dispatch, requirements↔test traceability, ESDB persistence, MCP server, and skills for Warp, Cursor, Claude Code, Copilot, Windsurf, and Aider."
 readme = "README.md"
 license = "MIT"

{specsmith-0.21.0.dev765 → specsmith-0.21.0.dev774}/src/epistemic/__init__.py

@@ -124,6 +124,7 @@ References
 - ARE:    https://github.com/organvm-i-theoria/auto-revision-epistemic-engine
 - VERITAS: https://github.com/AionSystem/VERITAS
 - Springer: https://doi.org/10.1007/s11948-023-00451-3
+
 """
 
 from __future__ import annotations

{specsmith-0.21.0.dev765 → specsmith-0.21.0.dev774}/src/epistemic/belief.py

@@ -45,6 +45,7 @@ References
 - ARE framework: https://github.com/organvm-i-theoria/auto-revision-epistemic-engine
 - VERITAS/CERTUS: https://github.com/AionSystem/VERITAS
 - AI as Epistemic Technology (Springer): https://doi.org/10.1007/s11948-023-00451-3
+
 """
 
 from __future__ import annotations
@@ -151,6 +152,7 @@ class BeliefArtifact:
             confidence=ConfidenceLevel.LOW,
             status=BeliefStatus.ACCEPTED,
         )
+
     """
 
     artifact_id: str
@@ -359,6 +361,6 @@ __all__ = [
     "ConfidenceLevel",
     "FailureMode",
     "FailureSeverity",
-    "parse_requirements_as_beliefs",
     "beliefs_from_dicts",
+    "parse_requirements_as_beliefs",
 ]

{specsmith-0.21.0.dev765 → specsmith-0.21.0.dev774}/src/epistemic/certainty.py

@@ -78,7 +78,7 @@ class CertaintyReport:
             lines.append("Artifacts below threshold:")
             for s in sorted(low, key=lambda x: x.propagated_score):
                 lines.append(
-                    f"  ✗ {s.artifact_id:25s}  score={s.propagated_score:.2f}  [{s.label}]"
+                    f"  ✗ {s.artifact_id:25s}  score={s.propagated_score:.2f}  [{s.label}]",
                 )
                 for note in s.notes[:2]:
                     lines.append(f"     {note}")
@@ -196,4 +196,4 @@ class CertaintyEngine:
                             changed = True
 
 
-__all__ = ["CertaintyEngine", "CertaintyReport", "ArtifactCertainty"]
+__all__ = ["ArtifactCertainty", "CertaintyEngine", "CertaintyReport"]

{specsmith-0.21.0.dev765 → specsmith-0.21.0.dev774}/src/epistemic/failure_graph.py

@@ -89,7 +89,7 @@ class FailureModeGraph:
         lines.append("=" * 50)
         lines.append(
             f"Equilibrium: {'✓ YES' if eq else '✗ NO'} | "
-            f"Nodes: {len(self._nodes)} | Logic Knots: {len(knots)}"
+            f"Nodes: {len(self._nodes)} | Logic Knots: {len(knots)}",
         )
 
         if knots:
@@ -128,8 +128,8 @@ class FailureModeGraph:
                 lines.append(f"  style {_sid(node.artifact_id)} fill:#ff4444,color:#fff")
             elif node.failure_count > 0:
                 lines.append(
-                    f'  {_sid(node.artifact_id)}["{label}\\n{node.failure_count} failures"]'
-                )  # noqa: E501
+                    f'  {_sid(node.artifact_id)}["{label}\\n{node.failure_count} failures"]',
+                )
                 lines.append(f"  style {_sid(node.artifact_id)} fill:#ff9900,color:#000")
             else:
                 lines.append(f'  {_sid(node.artifact_id)}["{label}"]')

{specsmith-0.21.0.dev765 → specsmith-0.21.0.dev774}/src/epistemic/recovery.py

@@ -71,7 +71,9 @@ class RecoveryOperator:
         return proposals
 
     def _propose_for_failure(
-        self, artifact: BeliefArtifact, fm: FailureMode
+        self,
+        artifact: BeliefArtifact,
+        fm: FailureMode,
     ) -> list[RecoveryProposal]:
         challenge = fm.challenge.lower()
         priority = _severity_priority(fm.severity)
@@ -90,9 +92,9 @@ class RecoveryOperator:
                     strategy=strategy,
                     description=f"Replace imprecise language in {artifact.artifact_id}.",
                     suggested_change=fm.recovery_hint
-                    or "Replace vague terms with measurable criteria.",  # noqa: E501
+                    or "Replace vague terms with measurable criteria.",
                     priority=priority,
-                )
+                ),
             )
         elif "falsifiability" in challenge or "no test" in challenge:
             proposals.append(
@@ -103,7 +105,7 @@ class RecoveryOperator:
                     description=f"Add a test for {artifact.artifact_id}.",
                     suggested_change=f"Add a test entry that covers: {artifact.source_text[:80]}",
                     priority=priority,
-                )
+                ),
             )
         elif "observability" in challenge or "boundary" in challenge:
             proposals.append(
@@ -114,7 +116,7 @@ class RecoveryOperator:
                     description=f"Add epistemic boundary to {artifact.artifact_id}.",
                     suggested_change="Declare scope, assumptions, and platform constraints.",
                     priority=priority,
-                )
+                ),
             )
             if not artifact.propositions:
                 proposals.append(
@@ -125,7 +127,7 @@ class RecoveryOperator:
                         description=f"Add propositions to {artifact.artifact_id} — currently empty.",  # noqa: E501
                         suggested_change="Add a description as a testable claim.",
                         priority=1,
-                    )
+                    ),
                 )
         elif "irreducibility" in challenge or "compound" in challenge:
             proposals.append(
@@ -137,7 +139,7 @@ class RecoveryOperator:
                     suggested_change="Split into separate beliefs, each with a single proposition.",
                     estimated_cost="medium",
                     priority=priority,
-                )
+                ),
             )
         elif "confidence" in challenge:
             proposals.append(
@@ -149,7 +151,7 @@ class RecoveryOperator:
                     suggested_change="Add test coverage, evidence citations, and mark as stress-tested.",  # noqa: E501
                     estimated_cost="medium",
                     priority=1,
-                )
+                ),
             )
 
         return proposals
@@ -171,7 +173,7 @@ class RecoveryOperator:
                     description=f"Resolve duplicate ID conflict between {id1} and {id2}.",
                     suggested_change="Merge or rename one with a unique ID.",
                     priority=1,
-                )
+                ),
             ]
         return [
             RecoveryProposal(
@@ -187,7 +189,7 @@ class RecoveryOperator:
                 ),
                 estimated_cost="medium",
                 priority=1,
-            )
+            ),
         ]
 
     def format_proposals(self, proposals: list[RecoveryProposal]) -> str:
@@ -202,8 +204,8 @@ class RecoveryOperator:
         ]
         for i, p in enumerate(proposals, 1):
             lines.append(
-                f"{i}. [{p.strategy.value.upper()}] {p.artifact_id} (cost: {p.estimated_cost})"
-            )  # noqa: E501
+                f"{i}. [{p.strategy.value.upper()}] {p.artifact_id} (cost: {p.estimated_cost})",
+            )
             lines.append(f"   Problem: {p.failure_mode_challenge}")
             lines.append(f"   Action:  {p.description}")
             lines.append(f"   Change:  {p.suggested_change[:200]}")

{specsmith-0.21.0.dev765 → specsmith-0.21.0.dev774}/src/epistemic/session.py

@@ -425,4 +425,4 @@ class AEESession:
         )
 
 
-__all__ = ["AEESession", "AEEResult"]
+__all__ = ["AEEResult", "AEESession"]

{specsmith-0.21.0.dev765 → specsmith-0.21.0.dev774}/src/epistemic/stress_tester.py

@@ -149,7 +149,7 @@ class StressTester:
                         breakpoint=f"Proposition '{prop[:80]}' contains imprecise language.",
                         severity=FailureSeverity.MEDIUM,
                         recovery_hint="Replace vague terms with specific, measurable criteria.",
-                    )
+                    ),
                 )
             if _VAGUE_QUANTITY.search(prop):
                 fms.append(
@@ -159,7 +159,7 @@ class StressTester:
                         breakpoint=f"Proposition '{prop[:80]}' uses an unquantified quantity.",
                         severity=FailureSeverity.LOW,
                         recovery_hint="Replace with a specific numeric bound or threshold.",
-                    )
+                    ),
                 )
         return fms
 
@@ -178,7 +178,7 @@ class StressTester:
                 ),
                 severity=FailureSeverity.HIGH,
                 recovery_hint="Add a test entry that covers this requirement.",
-            )
+            ),
         ]
 
     def _challenge_missing_boundary(self, artifact: BeliefArtifact) -> list[FailureMode]:
@@ -200,7 +200,7 @@ class StressTester:
                 ),
                 severity=FailureSeverity.LOW,
                 recovery_hint="Add an explicit epistemic boundary declaring scope and assumptions.",
-            )
+            ),
         ]
 
     def _challenge_compound_claim(self, artifact: BeliefArtifact) -> list[FailureMode]:
@@ -215,7 +215,7 @@ class StressTester:
                     ),
                     severity=FailureSeverity.LOW,
                     recovery_hint="Split into multiple, independently testable beliefs.",
-                )
+                ),
             ]
         for prop in artifact.propositions:
             if _COMPOUND_INDICATORS.search(prop):
@@ -226,7 +226,7 @@ class StressTester:
                         breakpoint=f"Proposition '{prop[:80]}' contains multiple claims.",
                         severity=FailureSeverity.LOW,
                         recovery_hint="Decompose into separate propositions.",
-                    )
+                    ),
                 ]
         return []
 
@@ -243,7 +243,7 @@ class StressTester:
                 ),
                 severity=FailureSeverity.CRITICAL,
                 recovery_hint="Add a description or explicit propositions.",
-            )
+            ),
         ]
 
     def _challenge_p1_confidence(self, artifact: BeliefArtifact) -> list[FailureMode]:
@@ -261,11 +261,13 @@ class StressTester:
                 ),
                 severity=FailureSeverity.CRITICAL,
                 recovery_hint="Stress-test, add evidence, or lower the priority.",
-            )
+            ),
         ]
 
     def _challenge_circular_links(
-        self, artifact: BeliefArtifact, id_set: set[str]
+        self,
+        artifact: BeliefArtifact,
+        id_set: set[str],
     ) -> list[FailureMode]:
         fms = []
         for link in artifact.inferential_links:
@@ -277,7 +279,7 @@ class StressTester:
                         breakpoint=f"{artifact.artifact_id} references '{link}' which does not exist.",  # noqa: E501
                         severity=FailureSeverity.MEDIUM,
                         recovery_hint=f"Remove or correct the link to '{link}'.",
-                    )
+                    ),
                 )
         return fms
 
@@ -293,7 +295,7 @@ class StressTester:
                         a.artifact_id,
                         seen[a.artifact_id],
                         "Duplicate belief ID — two accepted beliefs share the same identifier.",
-                    )
+                    ),
                 )
             seen[a.artifact_id] = a.artifact_id
 
@@ -312,7 +314,7 @@ class StressTester:
                                 a1.artifact_id,
                                 a2.artifact_id,
                                 f"Negation conflict in '{comp}': contradictory MUST/MUST NOT claims.",  # noqa: E501
-                            )
+                            ),
                         )
         return knots
 
@@ -352,4 +354,4 @@ def _extract_covered_reqs(test_path: Path) -> set[str]:
     return set(pattern.findall(content))
 
 
-__all__ = ["StressTester", "StressTestResult"]
+__all__ = ["StressTestResult", "StressTester"]

{specsmith-0.21.0.dev765 → specsmith-0.21.0.dev774}/src/epistemic/trace.py

@@ -142,13 +142,13 @@ class TraceVault:
             expected_content_hash = _sha256(expected_content)
             if rec.content_hash != expected_content_hash:
                 errors.append(
-                    f"{rec.seal_id}: content_hash invalid — description or metadata tampered"
+                    f"{rec.seal_id}: content_hash invalid — description or metadata tampered",
                 )
             # Verify entry_hash
             expected_entry = _sha256(f"{rec.content_hash}:{rec.prev_hash}")
             if rec.entry_hash != expected_entry:
                 errors.append(
-                    f"{rec.seal_id}: entry_hash invalid — record may have been tampered with"
+                    f"{rec.seal_id}: entry_hash invalid — record may have been tampered with",
                 )
             # Verify chain link
             if rec.prev_hash != prev_hash:
@@ -206,4 +206,4 @@ def _sha256(text: str) -> str:
     return hashlib.sha256(text.encode("utf-8")).hexdigest()
 
 
-__all__ = ["TraceVault", "SealRecord", "SealType"]
+__all__ = ["SealRecord", "SealType", "TraceVault"]

specsmith-0.21.0.dev774/src/specsmith/advanced_code_analysis.py

@@ -0,0 +1,307 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 Layer1Labs Silicon, Inc. All rights reserved.
+"""Advanced code analysis framework for specsmith with AI-assisted features."""
+
+import ast
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from specsmith.auditor import AuditResult
+from specsmith.code_analysis import ComplexityReport
+
+
+@dataclass
+class RefactoringSuggestion:
+    """A suggestion for code refactoring."""
+
+    file_path: str
+    line_number: int
+    suggestion_type: str
+    description: str
+    severity: str  # 'low', 'medium', 'high', 'critical'
+    confidence: float  # 0.0 to 1.0
+
+
+@dataclass
+class AIAssistedAnalysis:
+    """AI-assisted code analysis results."""
+
+    file_path: str
+    suggestions: list[RefactoringSuggestion]
+    code_quality_score: float
+    complexity_trend: str  # 'improving', 'stable', 'regressing'
+    improvement_potential: float  # 0.0 to 1.0
+
+
+class AdvancedCodeAnalyzer:
+    """Advanced code analysis engine with AI-assisted features."""
+
+    def __init__(self) -> None:
+        self.complexity_threshold = 10  # A-range complexity threshold
+
+    def analyze_file_for_refactoring(self, file_path: Path) -> list[RefactoringSuggestion]:
+        """Analyze a file for potential refactoring opportunities."""
+        suggestions: list[RefactoringSuggestion] = []
+
+        try:
+            with open(file_path, encoding="utf-8") as f:
+                content = f.read()
+
+            # Parse the file with AST
+            tree = ast.parse(content)
+
+            # Check for long functions (potential candidates for refactoring)
+            for node in ast.walk(tree):
+                if isinstance(node, ast.FunctionDef):
+                    # Calculate function length
+                    if hasattr(node, "body"):
+                        lines = node.body
+                        if len(lines) > 20:  # Arbitrary threshold for long functions
+                            description = (
+                                f"Function '{node.name}' has {len(lines)} lines - "
+                                "consider refactoring"
+                            )
+                            suggestions.append(
+                                RefactoringSuggestion(
+                                    file_path=str(file_path),
+                                    line_number=node.lineno,
+                                    suggestion_type="function_length",
+                                    description=description,
+                                    severity="medium",
+                                    confidence=0.7,
+                                )
+                            )
+
+                    # Check for complex conditionals
+                    complex_conditions = self._find_complex_conditions(node)
+                    for condition in complex_conditions:
+                        description = (
+                            f"Complex conditional at line {condition['line']} - "
+                            "consider simplification"
+                        )
+                        suggestions.append(
+                            RefactoringSuggestion(
+                                file_path=str(file_path),
+                                line_number=condition["line"],
+                                suggestion_type="conditional_complexity",
+                                description=description,
+                                severity="high",
+                                confidence=0.8,
+                            )
+                        )
+
+        except Exception:
+            # Silently ignore parsing errors for now
+            pass
+
+        return suggestions
+
+    def _find_complex_conditions(self, node: ast.AST) -> list[dict[str, Any]]:
+        """Find complex conditional statements."""
+        conditions: list[dict[str, Any]] = []
+        if isinstance(node, ast.If) and isinstance(node.test, ast.BoolOp):
+            # Check for nested if statements or complex boolean expressions
+            # Count the number of operations in boolean expressions
+            bool_op = node.test
+            if len(bool_op.values) > 3:  # More than 3 operands is complex
+                conditions.append(
+                    {
+                        "line": node.lineno,
+                        "type": "boolean_expression",
+                        "complexity": len(bool_op.values),
+                    }
+                )
+        return conditions
+
+    def analyze_codebase_for_ai_assistance(self, root: Path) -> dict[str, AIAssistedAnalysis]:
+        """Analyze entire codebase for AI-assisted insights."""
+        results = {}
+
+        # Analyze Python files
+        for py_file in root.rglob("*.py"):
+            # Skip test files and hidden directories
+            if "test" in str(py_file) or any(part.startswith(".") for part in py_file.parts):
+                continue
+
+            # Get complexity report
+            complexity_reports = self._analyze_file_complexity(py_file)
+
+            # Get refactoring suggestions
+            suggestions = self.analyze_file_for_refactoring(py_file)
+
+            # Calculate quality score
+            quality_score = self._calculate_quality_score(complexity_reports, suggestions)
+
+            # Determine complexity trend (simplified)
+            complexity_trend = self._determine_complexity_trend(complexity_reports)
+
+            results[str(py_file)] = AIAssistedAnalysis(
+                file_path=str(py_file),
+                suggestions=suggestions,
+                code_quality_score=quality_score,
+                complexity_trend=complexity_trend,
+                improvement_potential=self._calculate_improvement_potential(suggestions),
+            )
+
+        return results
+
+    def _analyze_file_complexity(self, file_path: Path) -> list[ComplexityReport]:
+        """Analyze complexity of a single file."""
+        # This would use the existing functionality from code_analysis.py
+        # For now, we'll create a simplified version
+        reports = []
+        try:
+            with open(file_path, encoding="utf-8") as f:
+                content = f.read()
+
+            tree = ast.parse(content)
+
+            # Walk through the AST to find function definitions
+            for node in ast.walk(tree):
+                if isinstance(node, ast.FunctionDef):
+                    complexity = self._calculate_complexity(node)
+                    if complexity > self.complexity_threshold:
+                        reports.append(
+                            ComplexityReport(
+                                file_path=str(file_path),
+                                function_name=node.name,
+                                complexity=complexity,
+                                line_number=node.lineno,
+                                message=(
+                                    f"Function '{node.name}' has cyclomatic complexity of "
+                                    f"{complexity}"
+                                ),
+                            )
+                        )
+        except Exception:
+            pass
+
+        return reports
+
+    def _calculate_complexity(self, node: ast.AST) -> int:
+        """Calculate cyclomatic complexity of an AST node."""
+        complexity = 1  # Base complexity
+
+        # Count control flow statements
+        for child in ast.iter_child_nodes(node):
+            if isinstance(child, (ast.If, ast.While, ast.For, ast.With, ast.Try)):
+                complexity += 1
+            elif isinstance(child, ast.BoolOp):
+                complexity += len(child.values) - 1
+            elif isinstance(child, ast.Compare):
+                complexity += len(child.comparators) - 1
+            elif isinstance(child, ast.ExceptHandler):
+                complexity += 1
+
+            # Recursively check children
+            complexity += self._calculate_complexity(child)
+
+        return complexity
+
+    def _calculate_quality_score(
+        self, complexity_reports: list[ComplexityReport], suggestions: list[RefactoringSuggestion]
+    ) -> float:
+        """Calculate overall code quality score."""
+        # Base score is 100
+        score = 100.0
+
+        # Deduct points for high complexity
+        high_complexity_count = len([r for r in complexity_reports if r.complexity > 10])
+        score -= high_complexity_count * 5
+
+        # Deduct points for refactoring suggestions
+        score -= len(suggestions) * 2
+
+        # Ensure score is within bounds
+        return max(0, min(100, score))
+
+    def _determine_complexity_trend(self, complexity_reports: list[ComplexityReport]) -> str:
+        """Determine if complexity is improving, stable, or regressing."""
+        if not complexity_reports:
+            return "stable"
+
+        # Simplified logic - in a real implementation, this would compare with historical data
+        high_complexity = [r for r in complexity_reports if r.complexity > 10]
+        if len(high_complexity) > 0:
+            return "regressing"
+        return "stable"
+
+    def _calculate_improvement_potential(self, suggestions: list[RefactoringSuggestion]) -> float:
+        """Calculate potential improvement based on suggestions."""
+        if not suggestions:
+            return 0.0
+
+        # Weight suggestions by severity
+        severity_weights = {
+            "low": 0.2,
+            "medium": 0.5,
+            "high": 0.8,
+            "critical": 1.0,
+        }
+
+        total_weight = sum(severity_weights.get(s.suggestion_type, 0.5) for s in suggestions)
+        return min(1.0, total_weight / len(suggestions) if suggestions else 0)
+
+
+def create_ai_assisted_code_report(root: Path) -> dict[str, AIAssistedAnalysis]:
+    """Create an AI-assisted code quality report."""
+    analyzer = AdvancedCodeAnalyzer()
+    return analyzer.analyze_codebase_for_ai_assistance(root)
+
+
+def generate_refactoring_report(root: Path) -> dict[str, list[RefactoringSuggestion]]:
+    """Generate a comprehensive refactoring report."""
+    analyzer = AdvancedCodeAnalyzer()
+    report = {}
+
+    # Analyze Python files
+    for py_file in root.rglob("*.py"):
+        # Skip test files and hidden directories
+        if "test" in str(py_file) or any(part.startswith(".") for part in py_file.parts):
+            continue
+
+        suggestions = analyzer.analyze_file_for_refactoring(py_file)
+        report[str(py_file)] = suggestions
+
+    return report
+
+
+def get_ai_assisted_analysis(root: Path) -> dict[str, AIAssistedAnalysis]:
+    """Get AI-assisted analysis for all files."""
+    return create_ai_assisted_code_report(root)
+
+
+def check_ai_compliance(root: Path) -> list[AuditResult]:
+    """Check AI compliance based on the analysis."""
+    issues = []
+
+    # Check if we have AI-assisted analysis capabilities
+    try:
+        analysis = get_ai_assisted_analysis(root)
+        if analysis:
+            issues.append(
+                AuditResult(
+                    name="ai-assisted-analysis",
+                    passed=True,
+                    message="AI-assisted code analysis capabilities are available",
+                )
+            )
+        else:
+            issues.append(
+                AuditResult(
+                    name="ai-assisted-analysis",
+                    passed=False,
+                    message="AI-assisted code analysis capabilities are not available",
+                )
+            )
+    except Exception as e:
+        issues.append(
+            AuditResult(
+                name="ai-assisted-analysis",
+                passed=False,
+                message=f"Error checking AI compliance: {e!s}",
+            )
+        )
+
+    return issues