modelable 1.0.0__py3-none-any.whl

modelable/llm/chat.py

@@ -0,0 +1,255 @@
+from __future__ import annotations
+
+import difflib
+import re
+import shlex
+from collections.abc import Iterable
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from modelable.compiler.workspace import Workspace
+from modelable.llm.context import (
+    build_model_summary,
+    build_projection_summary,
+    build_workspace_summary,
+    parse_model_ref,
+)
+from modelable.llm.engine import recommend_cli, update_definition
+from modelable.llm.providers import LLMProvider, LLMRequest
+from modelable.llm.qa import answer_question
+
+
+@dataclass
+class ChatState:
+    ref: str | None = None
+    workspace_summary: str | None = None
+    history: list[tuple[str, str]] = field(default_factory=list)
+
+
+CHAT_SYSTEM_PROMPT = """You are Modelable's interactive assistant.
+Answer using the current workspace context only.
+If the user asks for a model edit, explain that edit requests are previewed through the update pipeline and do not claim that files were written.
+If the user asks for a summary, be concise and factual.
+If the user asks a question you cannot answer from the context, say what is missing.
+"""
+
+
+def chat_reply(
+    workspace: Workspace,
+    message: str,
+    *,
+    ref: str | None = None,
+    workspace_summary: str | None = None,
+    provider: LLMProvider | None = None,
+    history: Iterable[tuple[str, str]] | None = None,
+) -> str:
+    if provider is None:
+        return answer_question(workspace, message)
+
+    user = _build_user_prompt(workspace, message, ref=ref, workspace_summary=workspace_summary, history=history)
+    response = provider.complete(LLMRequest(system=CHAT_SYSTEM_PROMPT, user=user, temperature=0.2))
+    return response.content.strip() or "No response returned."
+
+
+def chat_turn(
+    workspace: Workspace,
+    message: str,
+    *,
+    path: Path,
+    state: ChatState,
+    provider: LLMProvider | None = None,
+) -> str:
+    stripped = message.strip()
+    if stripped.startswith("/"):
+        response = _handle_chat_command(workspace, path, stripped, state=state, provider=provider)
+    elif _looks_like_update_request(stripped):
+        ref = _resolve_update_ref(stripped, state.ref)
+        if ref is None:
+            response = "Provide a ref or set one with /ref."
+        else:
+            instruction = _strip_update_ref_from_message(stripped, ref=ref)
+            try:
+                result = update_definition(path, ref, instruction, provider=provider, write=False)
+            except ValueError as exc:
+                response = f"ERROR: {exc}"
+            else:
+                response = _render_update_preview(result)
+    else:
+        response = chat_reply(
+            workspace,
+            message,
+            ref=state.ref,
+            workspace_summary=state.workspace_summary,
+            provider=provider,
+            history=state.history,
+        )
+    state.history.append(("user", message))
+    state.history.append(("assistant", response))
+    return response
+
+
+def _build_user_prompt(
+    workspace: Workspace,
+    message: str,
+    *,
+    ref: str | None = None,
+    workspace_summary: str | None = None,
+    history: Iterable[tuple[str, str]] | None = None,
+) -> str:
+    if ref is None:
+        context = workspace_summary or build_workspace_summary(workspace)
+    else:
+        context = _build_context_summary(workspace, ref=ref)
+    lines = [f"Workspace context:\n{context}"]
+    if history:
+        lines.append("Conversation:")
+        for role, text in history:
+            lines.append(f"{role}: {text}")
+    lines.append(f"user: {message}")
+    return "\n\n".join(lines)
+
+
+def _build_context_summary(workspace: Workspace, *, ref: str | None) -> str:
+    if ref is None:
+        return build_workspace_summary(workspace)
+    model_ref = parse_model_ref(ref)
+    domain = next((d for d in workspace.mdl.domains if d.name == model_ref.domain), None)
+    if domain is None:
+        return f"Unknown domain: {model_ref.domain}"
+    if model_ref.name in domain.models:
+        return build_model_summary(workspace, ref)
+    if model_ref.name in domain.projections:
+        return build_projection_summary(workspace, ref)
+    return f"Unknown model or projection: {ref}"
+
+
+def _handle_chat_command(
+    workspace: Workspace,
+    path: Path,
+    command_text: str,
+    *,
+    state: ChatState,
+    provider: LLMProvider | None,
+) -> str:
+    parts = shlex.split(command_text)
+    if not parts:
+        return "Empty command."
+    command = parts[0].lstrip("/").lower()
+    args = parts[1:]
+
+    if command in {"help", "?"}:
+        return _chat_help()
+    if command == "ref":
+        if not args:
+            return state.ref or "No focus ref is set."
+        state.ref = args[0]
+        return f"Focused on {state.ref}."
+    if command == "context":
+        return _build_context_summary(workspace, ref=state.ref)
+    if command == "describe":
+        ref = args[0] if args else state.ref
+        if ref:
+            return _build_context_summary(workspace, ref=ref)
+        return build_workspace_summary(workspace)
+    if command == "recommend":
+        ref = args[0] if args else state.ref
+        consumer = args[1] if len(args) > 1 else None
+        if ref is None:
+            return "Provide a ref or set one with /ref."
+        return recommend_cli(path, ref=ref, consumer=consumer)
+    if command == "ask":
+        question = " ".join(args).strip()
+        if not question:
+            return "Provide a question after /ask."
+        if provider is not None:
+            return chat_reply(
+                workspace,
+                question,
+                ref=state.ref,
+                workspace_summary=state.workspace_summary,
+                provider=provider,
+                history=state.history,
+            )
+        return answer_question(workspace, question)
+    if command == "update":
+        ref = args[0] if args else state.ref
+        if ref is None:
+            return "Provide a ref or set one with /ref."
+        instruction = " ".join(args[1:]).strip() if len(args) > 1 else ""
+        if not instruction:
+            return "Provide an edit instruction after /update."
+        try:
+            result = update_definition(path, ref, instruction, provider=provider, write=False)
+        except ValueError as exc:
+            return f"ERROR: {exc}"
+        return _render_update_preview(result)
+    if command in {"exit", "quit"}:
+        return "/exit"
+    return f"Unknown command: {command}. Try /help."
+
+
+def _chat_help() -> str:
+    return (
+        "Commands: /help, /ref <ref>, /context, /describe [ref], /recommend <ref> [consumer], "
+        "/ask <question>, /update <ref> <instruction> (preview only), /exit"
+    )
+
+
+def _render_update_preview(result) -> str:
+    return _render_update_result(result, written=False)
+
+
+def _render_update_result(result, *, written: bool = True) -> str:
+    diff = difflib.unified_diff(
+        result.original_content.splitlines(),
+        result.content.splitlines(),
+        fromfile=str(result.path),
+        tofile=f"{result.path} (preview)",
+        lineterm="",
+    )
+    rendered = "\n".join(diff)
+    if not rendered:
+        rendered = result.content
+    if result.warnings:
+        rendered += "\n" + "\n".join(f"WARN: {warning}" for warning in result.warnings)
+    if written:
+        rendered = f"Wrote changes to {result.path}\n{rendered}"
+    return rendered
+
+
+def _looks_like_update_request(message: str) -> bool:
+    lowered = message.lower().strip()
+    if lowered.endswith("?") and lowered.startswith(("how do i ", "how to ", "what is ", "why does ", "why is ")):
+        return False
+    if lowered.startswith(("please ", "please,", "could you ", "can you ", "would you ", "kindly ")):
+        return True
+    if re.match(r"^(make|rename|add|remove|delete|change|set|update|replace)\b", lowered):
+        return True
+    return any(
+        f" {verb} " in lowered
+        for verb in ("make", "rename", "add", "remove", "delete", "change", "set", "update", "replace")
+    )
+
+
+def _resolve_update_ref(message: str, fallback_ref: str | None) -> str | None:
+    explicit_ref = _find_model_ref_in_message(message)
+    if explicit_ref is not None:
+        return explicit_ref
+    return fallback_ref
+
+
+def _find_model_ref_in_message(message: str) -> str | None:
+    match = re.search(r"\b([A-Za-z_][A-Za-z0-9_-]*\.[A-Za-z_][A-Za-z0-9_-]*@\d+)\b", message)
+    if match is None:
+        return None
+    candidate = match.group(1)
+    try:
+        parse_model_ref(candidate)
+    except ValueError:
+        return None
+    return candidate
+
+
+def _strip_update_ref_from_message(message: str, *, ref: str) -> str:
+    cleaned = re.sub(rf"\b{re.escape(ref)}\b", "", message, count=1).strip()
+    return cleaned.lstrip(" ,:;-")

modelable/llm/config.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from os import environ
+
+from modelable.parser.ir import WorkspaceDef
+
+
+@dataclass(frozen=True)
+class LlmConfig:
+    provider: str | None
+    model: str | None
+    base_url: str | None
+    repair_attempts: int
+    source: str
+
+
+def resolve_llm_config(
+    *,
+    flag_provider: str | None = None,
+    flag_model: str | None = None,
+    flag_base_url: str | None = None,
+    workspace: WorkspaceDef | None = None,
+    env: dict[str, str] | None = None,
+    default_model: str = "modelable-local",
+) -> LlmConfig:
+    values = env or environ
+
+    provider = (
+        flag_provider
+        or values.get("MODELABLE_LLM_PROVIDER")
+        or (workspace.ai.provider if workspace and workspace.ai and workspace.ai.provider else None)
+    )
+
+    model = (
+        flag_model
+        or values.get("MODELABLE_LLM_MODEL")
+        or (workspace.ai.model if workspace and workspace.ai and workspace.ai.model else None)
+    )
+
+    base_url = flag_base_url or values.get("MODELABLE_LLM_BASE_URL") or values.get("OLLAMA_HOST")
+
+    repair_attempts = _resolve_repair_attempts(
+        flag_repair_attempts=None,
+        env_repair_attempts=values.get("MODELABLE_LLM_REPAIR_ATTEMPTS"),
+        workspace_repair_attempts=workspace.ai.repair_attempts if workspace and workspace.ai else None,
+    )
+
+    source = "default"
+    if flag_provider or flag_model or flag_base_url:
+        source = "flag"
+    elif (
+        values.get("MODELABLE_LLM_PROVIDER")
+        or values.get("MODELABLE_LLM_MODEL")
+        or values.get("MODELABLE_LLM_BASE_URL")
+        or values.get("MODELABLE_LLM_REPAIR_ATTEMPTS")
+    ):
+        source = "environment"
+    elif workspace and workspace.ai:
+        source = "workspace"
+
+    if provider is None and model is None:
+        model = default_model
+
+    return LlmConfig(provider=provider, model=model, base_url=base_url, repair_attempts=repair_attempts, source=source)
+
+
+def _resolve_repair_attempts(
+    *,
+    flag_repair_attempts: int | None,
+    env_repair_attempts: str | None,
+    workspace_repair_attempts: int | None,
+) -> int:
+    if flag_repair_attempts is not None:
+        if flag_repair_attempts < 0:
+            raise ValueError("MODELABLE_LLM_REPAIR_ATTEMPTS must be >= 0")
+        return flag_repair_attempts
+    if env_repair_attempts is not None:
+        value = int(env_repair_attempts)
+        if value < 0:
+            raise ValueError("MODELABLE_LLM_REPAIR_ATTEMPTS must be >= 0")
+        return value
+    if workspace_repair_attempts is not None:
+        if workspace_repair_attempts < 0:
+            raise ValueError("workspace ai.repair_attempts must be >= 0")
+        return workspace_repair_attempts
+    return 1

modelable/llm/context.py

@@ -0,0 +1,194 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from modelable.compiler.workspace import Workspace
+from modelable.parser.ir import (
+    ComputedMapping,
+    DirectMapping,
+    ProjectionField,
+    VersionMin,
+    VersionPinned,
+    VersionRange,
+    VersionSpec,
+)
+
+
+@dataclass(frozen=True)
+class ModelRef:
+    domain: str
+    name: str
+    version: int
+
+
+def parse_model_ref(ref: str) -> ModelRef:
+    if "@" not in ref or "." not in ref:
+        raise ValueError("REF must be in the form domain.Model@version")
+    model_ref, version_text = ref.rsplit("@", 1)
+    domain, name = model_ref.split(".", 1)
+    return ModelRef(domain=domain, name=name, version=int(version_text))
+
+
+def parse_model_ref_version_spec(ref: str) -> tuple[str, str, VersionSpec | int]:
+    if "@" not in ref or "." not in ref:
+        raise ValueError("REF must be in the form domain.Model@version")
+    model_ref, version_text = ref.rsplit("@", 1)
+    domain, name = model_ref.split(".", 1)
+    return domain, name, _parse_version_spec(version_text)
+
+
+def build_workspace_summary(workspace: Workspace) -> str:
+    lines: list[str] = []
+    for domain in workspace.mdl.domains:
+        lines.append(f"domain {domain.name}")
+        if domain.owner:
+            lines.append(f"  owner: {domain.owner}")
+        if domain.description:
+            lines.append(f"  description: {domain.description}")
+        for model_name, versions in domain.models.items():
+            for version in versions:
+                lines.append(
+                    f"  {version.model_kind.value} {model_name} @ {version.version} ({version.change_kind.value})"
+                )
+                for field in version.fields:
+                    lines.append(f"    - {field.name}: {_field_type_text(field.type)}")
+        for projection_name, versions in domain.projections.items():
+            for version in versions:
+                lines.append(f"  projection {projection_name} @ {version.version}")
+                lines.append(
+                    f"    from {version.source.model} @ {_version_text(version.source.version)} as {version.source.alias}"
+                )
+                for field in version.fields:
+                    lines.append(f"    - {field.name}")
+    return "\n".join(lines)
+
+
+def build_model_summary(workspace: Workspace, ref: str) -> str:
+    model_ref = parse_model_ref(ref)
+    domain = next((d for d in workspace.mdl.domains if d.name == model_ref.domain), None)
+    if domain is None:
+        return f"Unknown domain: {model_ref.domain}"
+    versions = domain.models.get(model_ref.name)
+    if not versions:
+        return f"Unknown model: {model_ref.domain}.{model_ref.name}"
+    version = next((item for item in versions if item.version == model_ref.version), None)
+    if version is None:
+        return f"Unknown model version: {ref}"
+
+    lines = [f"{model_ref.domain}.{model_ref.name}@{version.version}"]
+    lines.append(f"kind: {version.model_kind.value}")
+    lines.append(f"change: {version.change_kind.value}")
+    if domain.owner:
+        lines.append(f"owner: {domain.owner}")
+    if domain.description:
+        lines.append(f"description: {domain.description}")
+    for field in version.fields:
+        flags = []
+        if field.is_key:
+            flags.append("key")
+        if field.is_pii:
+            flags.append("pii")
+        if field.classification:
+            flags.append(f"classification={field.classification.value}")
+        suffix = f" [{', '.join(flags)}]" if flags else ""
+        lines.append(f"- {field.name}: {_field_type_text(field.type)}{suffix}")
+    return "\n".join(lines)
+
+
+def build_projection_summary(workspace: Workspace, ref: str) -> str:
+    model_ref = parse_model_ref(ref)
+    domain = next((d for d in workspace.mdl.domains if d.name == model_ref.domain), None)
+    if domain is None:
+        return f"Unknown domain: {model_ref.domain}"
+    versions = domain.projections.get(model_ref.name)
+    if not versions:
+        return f"Unknown projection: {model_ref.domain}.{model_ref.name}"
+    version = next((item for item in versions if item.version == model_ref.version), None)
+    if version is None:
+        return f"Unknown projection version: {ref}"
+
+    lines = [f"{model_ref.domain}.{model_ref.name}@{version.version}"]
+    lines.append(f"source: {version.source.model} @ {_version_text(version.source.version)} as {version.source.alias}")
+    if version.joins:
+        for join in version.joins:
+            lines.append(f"join: {join.model} @ {_version_text(join.version)} as {join.alias} on {join.on}")
+    if version.group_by:
+        lines.append(f"group by: {', '.join(version.group_by)}")
+    for field in version.fields:
+        lines.append(f"- {field.name}: {_projection_mapping_text(field)}")
+    return "\n".join(lines)
+
+
+def _field_type_text(field_type) -> str:
+    kind = getattr(field_type, "kind", None)
+    if kind is None:
+        return "unknown"
+    if kind == "decimal":
+        return f"decimal({field_type.precision}, {field_type.scale})"
+    if kind == "array":
+        return f"array<{_field_type_text(field_type.item)}>"
+    if kind == "map":
+        return f"map<{_field_type_text(field_type.key)}, {_field_type_text(field_type.value)}>"
+    if kind == "ref":
+        return f"ref<{field_type.target}>"
+    if kind == "enum":
+        return f"enum({', '.join(field_type.values)})"
+    if kind == "object":
+        return "object"
+    if kind == "named":
+        return field_type.name
+    return kind
+
+
+def _version_text(version_spec) -> str:
+    kind = getattr(version_spec, "kind", None)
+    if kind == "exact":
+        return str(version_spec.version)
+    if kind == "range":
+        return f">={version_spec.min_inclusive}<{version_spec.max_exclusive}"
+    if kind == "min":
+        return f">={version_spec.min_inclusive}"
+    if isinstance(version_spec, VersionPinned):
+        return f"{version_spec.version}#{version_spec.content_hash}"
+    return "?"
+
+
+def _projection_mapping_text(field: ProjectionField) -> str:
+    mapping = field.mapping
+    if isinstance(mapping, DirectMapping):
+        return f"direct {mapping.source_alias}.{mapping.source_field}"
+    if isinstance(mapping, ComputedMapping):
+        return f"computed {mapping.expression}"
+    return "unknown"
+
+
+_VERSION_RANGE_RE = re.compile(r"^>=\s*(\d+)\s*<\s*(\d+)$")
+_VERSION_MIN_RE = re.compile(r"^>=\s*(\d+)$")
+
+
+def _parse_version_spec(version_text: str) -> VersionSpec | int:
+    try:
+        return int(version_text)
+    except ValueError:
+        pass
+
+    pinned_match = re.match(r"^(\d+)\#([0-9a-fA-F]+)$", version_text)
+    if pinned_match:
+        return VersionPinned(
+            version=int(pinned_match.group(1)),
+            content_hash=pinned_match.group(2),
+        )
+
+    range_match = _VERSION_RANGE_RE.match(version_text)
+    if range_match:
+        return VersionRange(
+            min_inclusive=int(range_match.group(1)),
+            max_exclusive=int(range_match.group(2)),
+        )
+
+    min_match = _VERSION_MIN_RE.match(version_text)
+    if min_match:
+        return VersionMin(min_inclusive=int(min_match.group(1)))
+
+    raise ValueError("version must be an integer or version range like >=1<3")