intake-ai-cli 0.1.0__py3-none-any.whl

intake/__init__.py

@@ -0,0 +1,6 @@
+"""intake — From requirements in any format to verified implementation."""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"
+__app_name__ = "intake"

intake/__main__.py

@@ -0,0 +1,7 @@
+"""Allow running intake as a module: python -m intake."""
+
+from __future__ import annotations
+
+from intake.cli import main
+
+main()

intake/analyze/__init__.py

@@ -0,0 +1,8 @@
+"""Phase 2 — LLM-powered analysis of parsed content."""
+
+from __future__ import annotations
+
+from intake.analyze.analyzer import AnalyzeError, Analyzer
+from intake.analyze.models import AnalysisResult, DesignResult
+
+__all__ = ["AnalysisResult", "AnalyzeError", "Analyzer", "DesignResult"]

intake/analyze/analyzer.py

@@ -0,0 +1,224 @@
+"""Analyzer orchestrator — coordinates the LLM analysis pipeline.
+
+Flow:
+1. Combine text from all parsed sources
+2. Phase A — Extraction: LLM extracts structured requirements
+3. Deduplication: detect and remove repeated requirements across sources
+4. Validation: filter incomplete conflicts and questions
+5. Risk assessment: evaluate risk per requirement (optional)
+6. Design: architecture, tasks, and acceptance checks
+"""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING
+
+import structlog
+
+from intake.analyze.conflicts import validate_conflicts
+from intake.analyze.dedup import deduplicate
+from intake.analyze.design import parse_design
+from intake.analyze.extraction import parse_extraction
+from intake.analyze.models import DesignResult
+from intake.analyze.prompts import DESIGN_PROMPT, EXTRACTION_PROMPT, RISK_ASSESSMENT_PROMPT
+from intake.analyze.questions import validate_questions
+from intake.analyze.risks import parse_risks
+
+if TYPE_CHECKING:
+    from intake.analyze.models import AnalysisResult, RiskItem
+    from intake.config.schema import IntakeConfig
+    from intake.ingest.base import ParsedContent
+    from intake.llm import LLMAdapter
+
+logger = structlog.get_logger()
+
+
+class AnalyzeError(Exception):
+    """Base exception for analysis errors."""
+
+    def __init__(self, reason: str, suggestion: str = "") -> None:
+        self.reason = reason
+        self.suggestion = suggestion
+        msg = f"Analysis failed: {reason}"
+        if suggestion:
+            msg += f"\n  Hint: {suggestion}"
+        super().__init__(msg)
+
+
+class Analyzer:
+    """Orchestrates content analysis with LLM.
+
+    Coordinates extraction, deduplication, conflict validation,
+    risk assessment, and design phases into a single AnalysisResult.
+
+    Args:
+        config: Full intake configuration.
+        llm: LLM adapter for making completion calls.
+    """
+
+    def __init__(self, config: IntakeConfig, llm: LLMAdapter) -> None:
+        self.config = config
+        self.llm = llm
+
+    async def analyze(self, sources: list[ParsedContent]) -> AnalysisResult:
+        """Analyze multiple parsed sources and produce a structured result.
+
+        Args:
+            sources: List of parsed content from the ingest phase.
+
+        Returns:
+            Complete AnalysisResult with requirements, design, and metadata.
+
+        Raises:
+            AnalyzeError: If analysis fails.
+        """
+        if not sources:
+            raise AnalyzeError(
+                reason="No sources provided for analysis.",
+                suggestion="Pass at least one source file with -s.",
+            )
+
+        combined_text = self._combine_sources(sources)
+        total_words = sum(s.word_count for s in sources)
+
+        logger.info(
+            "analysis_starting",
+            sources=len(sources),
+            total_words=total_words,
+        )
+
+        # Phase A: Requirement extraction
+        extraction_raw = await self.llm.completion(
+            system_prompt=EXTRACTION_PROMPT.format(
+                n_sources=len(sources),
+                language=self.config.project.language,
+                requirements_format=self.config.spec.requirements_format,
+            ),
+            user_prompt=combined_text,
+            response_format="json",
+            phase="extraction",
+        )
+
+        if not isinstance(extraction_raw, dict):
+            msg = "LLM extraction did not return JSON"
+            raise AnalyzeError(msg, suggestion="Check your LLM model configuration.")
+        result = parse_extraction(extraction_raw)
+
+        # Deduplication
+        result.duplicates_removed = deduplicate(result)
+
+        # Validate conflicts and questions
+        result.conflicts = validate_conflicts(result.conflicts)
+        result.open_questions = validate_questions(result.open_questions)
+
+        # Risk assessment (conditional)
+        if self.config.spec.risk_assessment:
+            result.risks = await self._assess_risks(result)
+
+        # Design phase
+        result.design = await self._design(result)
+
+        # Metadata
+        result.total_cost = self.llm.total_cost
+        result.model_used = self.config.llm.model
+
+        logger.info(
+            "analysis_complete",
+            functional=len(result.functional_requirements),
+            non_functional=len(result.non_functional_requirements),
+            conflicts=len(result.conflicts),
+            questions=len(result.open_questions),
+            risks=len(result.risks),
+            tasks=len(result.design.tasks),
+            duplicates_removed=result.duplicates_removed,
+            cost=f"${result.total_cost:.4f}",
+        )
+
+        return result
+
+    def _combine_sources(self, sources: list[ParsedContent]) -> str:
+        """Combine multiple sources into a single text for the LLM.
+
+        Each source is prefixed with a header identifying its index,
+        file path, and format.
+        """
+        parts: list[str] = []
+        for i, source in enumerate(sources, 1):
+            header = (
+                f"=== SOURCE {i}: {source.source} "
+                f"(format: {source.format}) ==="
+            )
+            parts.append(f"{header}\n\n{source.text}")
+        return "\n\n---\n\n".join(parts)
+
+    async def _assess_risks(self, result: AnalysisResult) -> list[RiskItem]:
+        """Ask LLM to assess risks based on extracted requirements."""
+        requirements_data = [
+            {
+                "id": r.id,
+                "title": r.title,
+                "type": r.type,
+                "priority": r.priority,
+            }
+            for r in result.all_requirements
+        ]
+
+        conflicts_data = [
+            {
+                "id": c.id,
+                "description": c.description,
+                "severity": c.severity,
+            }
+            for c in result.conflicts
+        ]
+
+        risk_raw = await self.llm.completion(
+            system_prompt=RISK_ASSESSMENT_PROMPT.format(
+                language=self.config.project.language,
+                requirements_json=json.dumps(requirements_data, indent=2),
+                conflicts_json=json.dumps(conflicts_data, indent=2),
+            ),
+            user_prompt="Assess risks for the requirements above.",
+            response_format="json",
+            phase="risk_assessment",
+        )
+
+        if not isinstance(risk_raw, dict):
+            return []
+        return parse_risks(risk_raw)
+
+    async def _design(self, result: AnalysisResult) -> DesignResult:
+        """Ask LLM to produce technical design, tasks, and checks."""
+        requirements_data = [
+            {
+                "id": r.id,
+                "title": r.title,
+                "description": r.description,
+                "type": r.type,
+                "priority": r.priority,
+                "acceptance_criteria": r.acceptance_criteria,
+            }
+            for r in result.all_requirements
+        ]
+
+        project_stack = self.config.project.stack
+        stack = ", ".join(project_stack) if project_stack else "not specified"
+
+        design_raw = await self.llm.completion(
+            system_prompt=DESIGN_PROMPT.format(
+                language=self.config.project.language,
+                design_depth=self.config.spec.design_depth,
+                task_granularity=self.config.spec.task_granularity,
+                stack=stack,
+                file_tree="(not available)",
+                requirements_json=json.dumps(requirements_data, indent=2),
+            ),
+            user_prompt="Produce the technical design for these requirements.",
+            response_format="json",
+            phase="design",
+        )
+
+        if not isinstance(design_raw, dict):
+            return DesignResult()
+        return parse_design(design_raw)

intake/analyze/conflicts.py

@@ -0,0 +1,63 @@
+"""Conflict validation and enrichment.
+
+Validates conflicts extracted by the LLM and filters out
+low-quality or incomplete entries.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import structlog
+
+if TYPE_CHECKING:
+    from intake.analyze.models import Conflict
+
+logger = structlog.get_logger()
+
+
+def validate_conflicts(conflicts: list[Conflict]) -> list[Conflict]:
+    """Validate and filter extracted conflicts.
+
+    Removes conflicts that lack essential fields (description,
+    source references, or recommendation).
+
+    Args:
+        conflicts: Raw conflicts from the extraction phase.
+
+    Returns:
+        Filtered list of valid conflicts.
+    """
+    valid: list[Conflict] = []
+
+    for conflict in conflicts:
+        if _is_valid(conflict):
+            valid.append(conflict)
+        else:
+            logger.debug(
+                "conflict_filtered",
+                id=conflict.id,
+                reason="missing required fields",
+            )
+
+    filtered = len(conflicts) - len(valid)
+    if filtered > 0:
+        logger.info(
+            "conflicts_validated",
+            total=len(conflicts),
+            valid=len(valid),
+            filtered=filtered,
+        )
+
+    return valid
+
+
+def _is_valid(conflict: Conflict) -> bool:
+    """Check that a conflict has all required fields populated."""
+    if not conflict.description.strip():
+        return False
+    if not conflict.source_a:
+        return False
+    if not conflict.source_b:
+        return False
+    return bool(conflict.recommendation.strip())

intake/analyze/dedup.py

@@ -0,0 +1,115 @@
+"""Deduplication of requirements across multiple sources.
+
+Uses title similarity (normalized lowercase comparison) to detect
+duplicates within the same type (functional or non-functional).
+Keeps the first occurrence and removes subsequent duplicates.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+import structlog
+
+if TYPE_CHECKING:
+    from intake.analyze.models import AnalysisResult, Requirement
+
+logger = structlog.get_logger()
+
+# Minimum similarity ratio (0.0-1.0) to consider two requirements as duplicates.
+# Set at 0.75 for word-level Jaccard similarity (where small differences in
+# token count have a large impact on the ratio).
+SIMILARITY_THRESHOLD = 0.75
+
+
+def deduplicate(result: AnalysisResult) -> int:
+    """Remove duplicate requirements from the analysis result.
+
+    Modifies the result in place by removing duplicates from both
+    functional and non-functional requirement lists.
+
+    Args:
+        result: The analysis result to deduplicate.
+
+    Returns:
+        Number of duplicates removed.
+    """
+    fr_before = len(result.functional_requirements)
+    nfr_before = len(result.non_functional_requirements)
+
+    result.functional_requirements = _deduplicate_list(
+        result.functional_requirements
+    )
+    result.non_functional_requirements = _deduplicate_list(
+        result.non_functional_requirements
+    )
+
+    removed = (fr_before - len(result.functional_requirements)) + (
+        nfr_before - len(result.non_functional_requirements)
+    )
+
+    if removed > 0:
+        logger.info("dedup_complete", duplicates_removed=removed)
+
+    return removed
+
+
+def _deduplicate_list(requirements: list[Requirement]) -> list[Requirement]:
+    """Remove duplicates from a list of requirements.
+
+    Keeps the first occurrence of each unique requirement.
+    Two requirements are considered duplicates if their normalized
+    titles are similar above the threshold.
+    """
+    if not requirements:
+        return requirements
+
+    unique: list[Requirement] = []
+    seen_titles: list[str] = []
+
+    for req in requirements:
+        normalized = _normalize(req.title)
+        if not _is_duplicate(normalized, seen_titles):
+            unique.append(req)
+            seen_titles.append(normalized)
+
+    return unique
+
+
+def _is_duplicate(title: str, seen: list[str]) -> bool:
+    """Check if a normalized title is similar to any previously seen title."""
+    return any(_similarity(title, seen_title) >= SIMILARITY_THRESHOLD for seen_title in seen)
+
+
+def _normalize(text: str) -> str:
+    """Normalize text for comparison: lowercase, strip, collapse whitespace."""
+    text = text.lower().strip()
+    text = re.sub(r"\s+", " ", text)
+    return text
+
+
+def _similarity(a: str, b: str) -> float:
+    """Compute similarity ratio between two strings.
+
+    Uses token overlap (Jaccard similarity on words) for a lightweight,
+    dependency-free comparison.
+
+    Returns:
+        Float between 0.0 and 1.0 where 1.0 is identical.
+    """
+    if a == b:
+        return 1.0
+
+    tokens_a = set(a.split())
+    tokens_b = set(b.split())
+
+    if not tokens_a and not tokens_b:
+        return 1.0
+    if not tokens_a or not tokens_b:
+        return 0.0
+
+    intersection = tokens_a & tokens_b
+    union = tokens_a | tokens_b
+
+    return len(intersection) / len(union)

intake/analyze/design.py

@@ -0,0 +1,136 @@
+"""Design phase — parses LLM design output into typed models.
+
+Converts the DESIGN_PROMPT JSON response into DesignResult with
+components, file actions, tech decisions, tasks, and acceptance checks.
+"""
+
+from __future__ import annotations
+
+import structlog
+
+from intake.analyze.models import (
+    AcceptanceCheck,
+    DesignResult,
+    FileAction,
+    TaskItem,
+    TechDecision,
+)
+
+logger = structlog.get_logger()
+
+
+def parse_design(raw: dict[str, object]) -> DesignResult:
+    """Parse the LLM design response into a typed DesignResult.
+
+    Args:
+        raw: Parsed JSON dict from the LLM design call.
+
+    Returns:
+        DesignResult populated with components, files, tasks, and checks.
+    """
+    result = DesignResult()
+
+    # Components
+    components = raw.get("components", [])
+    if isinstance(components, list):
+        result.components = [str(c) for c in components]
+
+    # Files to create
+    for item in _get_list(raw, "files_to_create"):
+        result.files_to_create.append(
+            FileAction(
+                path=str(item.get("path", "")),
+                description=str(item.get("description", "")),
+                action="create",
+            )
+        )
+
+    # Files to modify
+    for item in _get_list(raw, "files_to_modify"):
+        result.files_to_modify.append(
+            FileAction(
+                path=str(item.get("path", "")),
+                description=str(item.get("description", item.get("changes", ""))),
+                action="modify",
+            )
+        )
+
+    # Tech decisions
+    for item in _get_list(raw, "tech_decisions"):
+        result.tech_decisions.append(
+            TechDecision(
+                decision=str(item.get("decision", "")),
+                justification=str(item.get("justification", "")),
+                requirement=str(item.get("requirement", "")),
+            )
+        )
+
+    # Tasks
+    for item in _get_list(raw, "tasks"):
+        result.tasks.append(_parse_task(item))
+
+    # Acceptance checks
+    for item in _get_list(raw, "acceptance_checks"):
+        result.acceptance_checks.append(_parse_check(item))
+
+    # Dependencies
+    deps = raw.get("dependencies", [])
+    if isinstance(deps, list):
+        result.dependencies = [str(d) for d in deps]
+
+    logger.info(
+        "design_parsed",
+        components=len(result.components),
+        files_create=len(result.files_to_create),
+        files_modify=len(result.files_to_modify),
+        tasks=len(result.tasks),
+        checks=len(result.acceptance_checks),
+    )
+
+    return result
+
+
+def _parse_task(item: dict[str, object]) -> TaskItem:
+    """Parse a single task from the LLM output."""
+    files = item.get("files", [])
+    deps = item.get("dependencies", [])
+    checks = item.get("checks", [])
+
+    raw_id = item.get("id", 0)
+    raw_minutes = item.get("estimated_minutes", 15)
+    return TaskItem(
+        id=int(raw_id) if isinstance(raw_id, (int, float, str)) else 0,
+        title=str(item.get("title", "")),
+        description=str(item.get("description", "")),
+        files=[str(f) for f in files] if isinstance(files, list) else [],
+        dependencies=[int(d) for d in deps] if isinstance(deps, list) else [],
+        checks=[str(c) for c in checks] if isinstance(checks, list) else [],
+        estimated_minutes=int(raw_minutes) if isinstance(raw_minutes, (int, float, str)) else 15,
+    )
+
+
+def _parse_check(item: dict[str, object]) -> AcceptanceCheck:
+    """Parse a single acceptance check from the LLM output."""
+    tags = item.get("tags", [])
+    paths = item.get("paths", [])
+    patterns = item.get("patterns", [])
+
+    return AcceptanceCheck(
+        id=str(item.get("id", "")),
+        name=str(item.get("name", "")),
+        type=str(item.get("type", "command")),
+        required=bool(item.get("required", True)),
+        tags=[str(t) for t in tags] if isinstance(tags, list) else [],
+        command=str(item.get("command", "")),
+        paths=[str(p) for p in paths] if isinstance(paths, list) else [],
+        glob=str(item.get("glob", "")),
+        patterns=[str(p) for p in patterns] if isinstance(patterns, list) else [],
+    )
+
+
+def _get_list(data: dict[str, object], key: str) -> list[dict[str, object]]:
+    """Safely extract a list from a dict, returning empty list on failure."""
+    value = data.get(key, [])
+    if not isinstance(value, list):
+        return []
+    return [item for item in value if isinstance(item, dict)]

intake/analyze/extraction.py

@@ -0,0 +1,113 @@
+"""Phase A — Extract structured requirements from raw LLM output.
+
+Parses the JSON response from EXTRACTION_PROMPT into typed dataclasses.
+"""
+
+from __future__ import annotations
+
+import structlog
+
+from intake.analyze.models import (
+    AnalysisResult,
+    Conflict,
+    OpenQuestion,
+    Requirement,
+)
+
+logger = structlog.get_logger()
+
+
+def parse_extraction(raw: dict[str, object]) -> AnalysisResult:
+    """Parse the LLM JSON response into a typed AnalysisResult.
+
+    Args:
+        raw: Parsed JSON dict from the LLM extraction call.
+
+    Returns:
+        AnalysisResult populated with requirements, conflicts, and questions.
+    """
+    result = AnalysisResult()
+
+    for item in _get_list(raw, "functional_requirements"):
+        result.functional_requirements.append(_parse_requirement(item, "functional"))
+
+    for item in _get_list(raw, "non_functional_requirements"):
+        result.non_functional_requirements.append(
+            _parse_requirement(item, "non_functional")
+        )
+
+    for item in _get_list(raw, "conflicts"):
+        result.conflicts.append(_parse_conflict(item))
+
+    for item in _get_list(raw, "open_questions"):
+        result.open_questions.append(_parse_open_question(item))
+
+    logger.info(
+        "extraction_parsed",
+        functional=len(result.functional_requirements),
+        non_functional=len(result.non_functional_requirements),
+        conflicts=len(result.conflicts),
+        questions=len(result.open_questions),
+    )
+
+    return result
+
+
+def _parse_requirement(item: dict[str, object], req_type: str) -> Requirement:
+    """Parse a single requirement from the LLM output."""
+    return Requirement(
+        id=str(item.get("id", "")),
+        type=req_type,
+        title=str(item.get("title", "")),
+        description=str(item.get("description", "")),
+        acceptance_criteria=_get_str_list(item, "acceptance_criteria"),
+        source=str(item.get("source", "")),
+        priority=str(item.get("priority", "medium")),
+    )
+
+
+def _parse_conflict(item: dict[str, object]) -> Conflict:
+    """Parse a single conflict from the LLM output."""
+    source_a = item.get("source_a", {})
+    source_b = item.get("source_b", {})
+
+    return Conflict(
+        id=str(item.get("id", "")),
+        description=str(item.get("description", "")),
+        source_a=_to_str_dict(source_a) if isinstance(source_a, dict) else {},
+        source_b=_to_str_dict(source_b) if isinstance(source_b, dict) else {},
+        recommendation=str(item.get("recommendation", "")),
+        severity=str(item.get("severity", "medium")),
+    )
+
+
+def _parse_open_question(item: dict[str, object]) -> OpenQuestion:
+    """Parse a single open question from the LLM output."""
+    return OpenQuestion(
+        id=str(item.get("id", "")),
+        question=str(item.get("question", "")),
+        context=str(item.get("context", "")),
+        source=str(item.get("source", "")),
+        recommendation=str(item.get("recommendation", "")),
+    )
+
+
+def _get_list(data: dict[str, object], key: str) -> list[dict[str, object]]:
+    """Safely extract a list of dicts from a dict, returning empty list on failure."""
+    value = data.get(key, [])
+    if not isinstance(value, list):
+        return []
+    return [item for item in value if isinstance(item, dict)]
+
+
+def _get_str_list(data: dict[str, object], key: str) -> list[str]:
+    """Safely extract a list of strings from a dict."""
+    value = data.get(key, [])
+    if not isinstance(value, list):
+        return []
+    return [str(item) for item in value]
+
+
+def _to_str_dict(data: dict[str, object]) -> dict[str, str]:
+    """Convert a dict with mixed values to a dict with string values."""
+    return {str(k): str(v) for k, v in data.items()}