speclogician 0.0.0b1__py3-none-any.whl → 0.0.0.dev1__py3-none-any.whl

speclogician/llms/overlay.py

@@ -0,0 +1,264 @@
+# 
+#   Imandra Inc.
+#
+#   overlay.py
+#
+
+
+import yaml, os
+from pydantic import BaseModel
+from rich import print
+from rich.console import Console
+from typing import List, Optional
+from rich.panel import Panel
+from rich.table import Table
+from rich.syntax import Syntax
+from rich.markdown import Markdown
+from rich.console import RenderableType
+
+# ----------------------------
+# Example field
+# ----------------------------
+
+class Example(BaseModel):
+    source: str      # original snippet in the source DSL/language
+    iml: str         # expected IML output
+
+
+# ----------------------------
+# Mapping section
+# ----------------------------
+
+class TitleMapping(BaseModel):
+    type: str
+    pattern: str
+    extract: int
+
+
+class SectionMapping(BaseModel):
+    keywords: Optional[List[str]] = None
+    chained_keywords: Optional[List[str]] = None
+    section: Optional[str] = None
+    transform: Optional[str] = None
+
+
+class Mapping(BaseModel):
+    title: TitleMapping
+    given: SectionMapping
+    when: SectionMapping
+    then: SectionMapping
+
+
+# ----------------------------
+# Background
+# ----------------------------
+
+class Background(BaseModel):
+    enabled: bool
+    keywords: List[str]
+    given_keywords: List[str]
+
+
+# ----------------------------
+# State configuration
+# ----------------------------
+
+class StateConfig(BaseModel):
+    initial_name: str
+    transition_prefix: str
+
+
+# ----------------------------
+# Rules and constraints
+# ----------------------------
+
+class Rules(BaseModel):
+    state_transitions: List[str]
+    predicates: List[str]
+
+
+class YamlConstraints(BaseModel):
+    double_quote_strings: bool
+    escape_quotes: bool
+
+
+# ----------------------------
+# MAIN OVERLAY MODEL
+# ----------------------------
+
+class Overlay(BaseModel):
+    language: str
+    name: str
+    description: str
+    ext : str
+
+    mapping: Mapping
+    background: Background
+    state: StateConfig
+    rules: Rules
+    yaml_constraints: YamlConstraints
+
+    notes: List[str]
+
+    # NEW: structured example consisting of source + IML
+    example: Optional[Example] = None
+
+    def to_yaml (self):
+        data = self.model_dump()     # Pydantic → dict
+        return yaml.safe_dump(data, sort_keys=False)
+
+    # --------------------------------------------------
+    # Rich pretty-printer
+    # --------------------------------------------------
+    def __rich__(self) -> RenderableType:
+        root = Table.grid(padding=1)
+        root.title = f"[bold cyan]Overlay ({self.language})[/bold cyan]"
+
+        # Metadata
+        meta = Table(show_header=False, box=None)
+        meta.add_row("[bold]Name[/bold]", self.name)
+        meta.add_row("[bold]Language[/bold]", self.language)
+        meta.add_row("[bold]Description[/bold]", self.description)
+        root.add_row(Panel(meta, title="Metadata", border_style="cyan"))
+
+        # Mapping
+        map_table = Table(show_header=True, header_style="bold magenta")
+        map_table.add_column("Section")
+        map_table.add_column("Keywords")
+        map_table.add_column("Chained")
+        map_table.add_column("Transform")
+
+        def fmt(xs):
+            return ", ".join(xs) if xs else ""
+
+        map_table.add_row(
+            "Title",
+            f"{self.mapping.title.type} / {self.mapping.title.pattern}",
+            "",
+            f"extract={self.mapping.title.extract}",
+        )
+
+        for name, sec in [
+            ("Given", self.mapping.given),
+            ("When", self.mapping.when),
+            ("Then", self.mapping.then),
+        ]:
+            map_table.add_row(
+                name,
+                fmt(sec.keywords),
+                fmt(sec.chained_keywords),
+                sec.transform or "",
+            )
+
+        root.add_row(Panel(map_table, title="Mapping", border_style="magenta"))
+
+        # Background
+        bg = Table(show_header=False, box=None)
+        bg.add_row("[bold]Enabled[/bold]", str(self.background.enabled))
+        bg.add_row("[bold]Keywords[/bold]", fmt(self.background.keywords))
+        bg.add_row("[bold]Given Keywords[/bold]", fmt(self.background.given_keywords))
+        root.add_row(Panel(bg, title="Background", border_style="green"))
+
+        # State Config
+        st = Table(show_header=False, box=None)
+        st.add_row("[bold]Initial[/bold]", self.state.initial_name)
+        st.add_row("[bold]Transition Prefix[/bold]", self.state.transition_prefix)
+        root.add_row(Panel(st, title="State Config", border_style="yellow"))
+
+        # Rules
+        rules_t = Table(show_header=True, header_style="bold blue")
+        rules_t.add_column("State Transitions")
+        rules_t.add_column("Predicates")
+
+        max_len = max(len(self.rules.state_transitions), len(self.rules.predicates))
+        for i in range(max_len):
+            left = self.rules.state_transitions[i] if i < len(self.rules.state_transitions) else ""
+            right = self.rules.predicates[i] if i < len(self.rules.predicates) else ""
+            rules_t.add_row(left, right)
+
+        root.add_row(Panel(rules_t, title="Rules", border_style="blue"))
+
+        # YAML Constraints
+        yc = Table(show_header=False, box=None)
+        yc.add_row("[bold]Double Quote Strings[/bold]", str(self.yaml_constraints.double_quote_strings))
+        yc.add_row("[bold]Escape Quotes[/bold]", str(self.yaml_constraints.escape_quotes))
+        root.add_row(Panel(yc, title="YAML Constraints", border_style="red"))
+
+        # Notes
+        notes_md = Markdown("\n".join(f"- {n}" for n in self.notes))
+        root.add_row(Panel(notes_md, title="Notes", border_style="white"))
+
+        # Structured Example
+        if self.example:
+            # Original source language
+            source_block = Syntax(
+                self.example.source,
+                self.language,  # use overlay.language for syntax highlighting
+                theme="monokai",
+                line_numbers=False,
+            )
+            root.add_row(Panel(source_block, title="Example (Source)", border_style="bright_magenta"))
+
+            # IML output
+            iml_block = Syntax(
+                self.example.iml,
+                "ocaml",   # Imandra IML is OCaml-like
+                theme="monokai",
+                line_numbers=False,
+            )
+            root.add_row(Panel(iml_block, title="Example (IML)", border_style="bright_green"))
+
+        return Panel(root, border_style="bright_white")
+    
+    @staticmethod
+    def from_file(path:str) -> 'Overlay':
+        """Load an overlay YAML file and parse it into the Overlay model."""
+        with open(path, "r", encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+
+        overlay : Overlay = Overlay.model_validate(data)
+        return overlay
+
+class Overlays(BaseModel):
+    """
+    """
+    overlays : list[Overlay]
+
+    def list_overlays(self):
+        for o in self.overlays:
+            print ('---' * 10)
+            print (f"Name: {o.name}")
+            print (f"Language: {o.language}")
+            print (f"Description: {o.description}")
+
+    def names(self) -> list[str]:
+        return list(map(lambda x: x.name, self.overlays))
+
+    def get(self, name:str) -> Overlay|None:
+        if name in self.names():
+            return next(filter(lambda x: x.name == name, self.overlays))
+        else:
+            return None
+
+    @staticmethod
+    def from_dir(dir_path:str) -> 'Overlays':
+        overlays : list[Overlay] = []
+        for file in os.listdir(dir_path):
+            if file.endswith('.yaml'):
+                overlays.append(Overlay.from_file(os.path.join(dir_path, file)))
+        
+        return Overlays(overlays=overlays)
+
+
+if __name__ == "__main__":
+    import sys
+
+    if len(sys.argv) < 2:
+        print("[red]Usage: python load_overlay.py <overlay.yaml>[/red]")
+        sys.exit(1)
+
+    overlay_file = sys.argv[1]
+    overlay = Overlay.from_file(overlay_file)
+
+    console = Console()
+    console.print(overlay)

speclogician/main.py

@@ -1,47 +1,26 @@
 #
 #   Imandra Inc.
 #
-#   speclogician/main.py
+#   main.py
 #
 
-__version__ = "1.0"
-
 import typer
+import os
 from typing import Final
 from pathlib import Path
 
-from speclogician.commands import ch_app, view_app, find_app
-from speclogician.presentation.preview import preview_app
-from speclogician.demos.cmd_demo import app as demo_app
-from speclogician.utils import console, require_imandra_key
-from speclogician.utils.load import load_state
-from speclogician.state.state import State
-
-
-SL_HELP : Final = """
-:robot: [bold deep_sky_blue1][italic]SpecLogician[/italic] is an AI framework for data-driven 
-formal program specification synthesis, verification, and analysis.[/bold deep_sky_blue1] :rocket:
-
-SpecLogician provides an LLM-native alternative to classical predicate abstraction and
-Counterexample-Guided Abstraction Refinement (CEGAR).
+from speclogician.cmd.agent_cmd import app as agent_app
+from speclogician.cmd.data_cmd import app as data_app
+from speclogician.cmd.model_cmd import app as model_app
+from speclogician.cmd.overlay_cmd import app as overlay_app
+from speclogician.cmd.scenario_cmd import app as scenario_app
+from speclogician.cmd.state_cmd import app as state_app
 
-Instead of requiring users or agents to discover and maintain global Boolean abstractions,
-SpecLogician models behavior directly using structured scenarios composed from state and
-action predicates. Specifications are built incrementally by defining a domain base
-(types and core invariants), predicates, transition functions, and scenarios that capture
-intent explicitly.
+from speclogician.utils import console
 
-Each change creates a new immutable state, triggers precise logical analysis, and produces
-a semantic diff against the previous state. Using ImandraX’s exact symbolic reasoning and
-region decomposition, SpecLogician computes coverage, conflicts, reachability, and
-behavioral complements—identifying real, reachable behaviors not yet explained by any
-scenario.
 
-Rather than reacting to spurious counterexamples, users and AI agents receive positive,
-actionable refinement signals in the form of uncovered or inconsistent behavioral regions.
-This enables scalable, explainable refinement toward correctness and completeness across
-source code, tests, documentation, and real-world traces—using small, explicit change
-commands instead of manual file editing.
+SL_HELP : Final = """
+:robot: [bold deep_sky_blue1][italic]SpecLogician[/italic] is an AI framework for data-driven formal program specification synthesis, verification and analysis.[/bold deep_sky_blue1] :rocket:
 
 Learn more at [bold italic deep_sky_blue1]https://www.speclogician.dev![/bold italic deep_sky_blue1]
 """
@@ -49,91 +28,46 @@ Learn more at [bold italic deep_sky_blue1]https://www.speclogician.dev![/bold it
 app = typer.Typer(
     name="SpecLogician",
     help=SL_HELP,
-    rich_markup_mode="rich",
-    no_args_is_help=True
+    rich_markup_mode="rich"
 )
 
-class AppCtx:
-    state_json_path: Path | None = None
-    state: State | None = None
-
-@app.callback()
-def _cli_entry() -> None:
-    """
-    SpecLogician CLI entry point.
-    """
-    require_imandra_key()
-
-@app.callback()
-def main(ctx: typer.Context, state_json: Path | None = typer.Option(None, "--state-json", help="...")):
-    ctx.obj = ctx.ensure_object(AppCtx)
-
-    ctx.obj.state_json_path = state_json
-
-    if state_json:
-        try:
-            ctx.obj.state = load_state(path=state_json)
-        except Exception:
-            ctx.obj.state = None
-    else:
-        ctx.obj.state = None  # ✅ ensure attribute exists
-
-app.add_typer(view_app      , name="view"       , help="View components of the state")
-app.add_typer(ch_app        , name="ch"         , help="Apply change to the state")
-app.add_typer(find_app      , name="find"       , help="Search for a components of the state")
-app.add_typer(demo_app      , name="demo"       , help="A collection of SpecLogician demos")
-app.add_typer(preview_app   , name="preview"    , hidden=True) # This is an internal tool for manually inspecting renderers
-
+app.add_typer(agent_app     , name="agent"      , help="Agentic functions")
+app.add_typer(overlay_app   , name="overlay"    , help="Available overlays")
+app.add_typer(data_app      , name="data"       , help="Functions for data artifacts")
+app.add_typer(model_app     , name="model"      , help="Functions related to model")
+app.add_typer(scenario_app  , name="scenario"   , help="Scenario access and modification functions")
+app.add_typer(state_app     , name="state"      , help="State access and modification functions")
 
 @app.command(help="Run the TUI")
 def tui ():
-    """ Run the TUI to help us navigate and explore the state """
-    from speclogician.tui.app import SpecLogicianApp
-    tui_app = SpecLogicianApp()
+    """
+    Launch the TUI view of the state
+    """
+    from tui.tui import SpecLogicianApp
+    tui_app = SpecLogicianApp(state)
     tui_app.run()
 
 @app.command(help="Generate a prompt for helping agents use SpecLogician")
-def prompt(
-    out: Path | None = typer.Option(
-        None,
-        "--out",
-        help="Write the prompt to a file instead of stdout.",
-    ),
-):
+def prompt():
     """
-    Generate a prompt for helping CLI agents use SpecLogician.
+    Generate a prompt for helping CLI agents use SpecLogician
     """
 
-    here = Path(__file__).resolve()
-    repo_root = here.parents[0]
-    prompt_path = repo_root / "utils" / "prompt.md"
+    prompt_path = Path(os.path.abspath(__file__)).parent / "utils/prompt.md"
 
     try:
-        txt = prompt_path.read_text()
+        contents = prompt_path.read_text()
     except Exception as e:
-        console.print(f"🛑 Failed to read prompt file at {prompt_path}: {e}")
-        raise typer.Exit(2)
-
-    if out:
-        try:
-            out.write_text(txt)
-        except Exception as e:
-            console.print(f"🛑 Failed to write prompt to {out}: {e}")
-            raise typer.Exit(2)
-        typer.echo(str(out))
-    else:
-        typer.echo(txt)
+        console.print(f"🛑 Failed to read in the prompt contents: {e}")
+        return
     
-
-@app.command()
-def version(
-    json_only: bool = typer.Option(False, "--json", help="Output JSON"),
-):
-    """Print SpecLogician version"""
-    if json_only:
-        typer.echo(f'{{"version": "{__version__}"}}')
-    else:
-        typer.echo(__version__)
+    console.rule("[bold]Start of SpecLogician prompt[/bold]")
+    console.print(contents)
+    console.rule("[bold]End of prompt[/bold]")
 
 if __name__ == '__main__':
     app()
+    import sys
+    sys.exit(0)
+    print ("hello")
+    state.save(dirpath=os.getcwd())

speclogician/modeling/__init__.py

@@ -1,31 +0,0 @@
-#
-#   Imandra Inc.
-#
-#   speclogician/modeling/__init__.py
-#
-
-
-import re
-from typing import List
-
-IML_TYPE_REGEX = re.compile(
-    r"""
-    ^\s*type\s+                    # 'type' keyword
-    (?P<name>[a-zA-Z_][a-zA-Z0-9_]*)  # type name
-    \s*=                            # '=' sign
-    """,
-    re.MULTILINE | re.VERBOSE,
-)
-
-def strip_iml_comments(text: str) -> str:
-    """Remove OCaml-style (* ... *) and // comments."""
-    # Remove block comments
-    text = re.sub(r"\(\*.*?\*\)", "", text, flags=re.DOTALL)
-    # Remove line comments
-    text = re.sub(r"//.*", "", text)
-    return text
-
-def extract_declared_types(iml_text: str) -> List[str]:
-    """Return all declared type names in an IML file."""
-    clean = strip_iml_comments(iml_text)
-    return [m.group("name") for m in IML_TYPE_REGEX.finditer(clean)]

speclogician/modeling/component.py

@@ -1,71 +1,15 @@
 #
 #   Imandra Inc.
 #
-#   speclogician/modeling/component.py
+#   component.py
 #
 
 import uuid
-import re
-from datetime import datetime, timezone
-from pydantic import BaseModel, Field, field_validator, ConfigDict
-from ..utils import IMLValidity
-
-_NAME_RE = re.compile(r"^[a-z][a-z0-9_]*$")
-
-# Conservative reserved set (OCaml-ish + common IML surface syntax).
-# Add more as you run into them.
-_IML_RESERVED: set[str] = {
-    # core keywords / syntax
-    "let", "in", "and", "rec",
-    "type", "match", "with", "function",
-    "if", "then", "else",
-    "try", "raise",
-    "module", "open", "include",
-    "begin", "end",
-    "as", "of", "when",
-
-    # booleans / common literals
-    "true", "false",
-
-    # common types / constructors that are often special-cased
-    "some", "none",
-}
-
-def validate_iml_identifier(name: str) -> str:
-    if not _NAME_RE.fullmatch(name):
-        raise ValueError(
-            f"Invalid name '{name}'. Must start with a lowercase letter and contain only "
-            "lowercase letters, digits, and underscores."
-        )
-    if name in _IML_RESERVED:
-        raise ValueError(f"Invalid name '{name}': reserved keyword in IML/OCaml surface syntax.")
-    return name
+from pydantic import BaseModel, Field
 
 class ModelComponent(BaseModel):
     """
-    Base class for all model components (Predicates, transitions and scenarios)
     """
-    model_config = ConfigDict(validate_assignment=True)  # optional but recommended
-
-    comp_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
-    name: str
-
-    # Track last update time (UTC)
-    last_updated: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
-
-    @field_validator("name")
-    @classmethod
-    def validate_name(cls, v: str) -> str:
-        return validate_iml_identifier(v)
-
-    def touch(self) -> None:
-        self.last_updated = datetime.now(timezone.utc)
-    
-class SrcComponent(ModelComponent):
-    src_code: str = ""
-    is_iml_valid : IMLValidity = IMLValidity.UNKNOWN
-    iml_error: str | None = None
 
-    def set_src_code(self, src_code: str) -> None:
-        self.src_code = src_code
-        self.touch()
+    comp_id : str = Field(default_factory=lambda: str(uuid.uuid4())) # assigned task ID, new one created if not provided
+    

speclogician/modeling/conflict.py

@@ -1,26 +1,12 @@
 #
 #   Imandra Inc.    
 #
-#   speclogician/modeling/conflict.py
+#   conflict.py
 #
 
 from pydantic import BaseModel
-from typing import Literal, TypeAlias
 
-class ScenarioOverlap(BaseModel):
-    """ Two scenarios overlap in constraints """
-    kind: Literal["overlap"] = "overlap"
-    scenario_name1 : str
-    scenario_name2 : str
-
-    details : str
-
-class ScenarioConsumed(BaseModel):
-    """ One scenario fully absorbs another """
-    kind: Literal["consumed"] = "consumed"
-    scenario_name1 : str
-    scenario_name2 : str
-
-    details : str
-
-ScenarioConflict : TypeAlias = ScenarioOverlap | ScenarioConsumed
+class Conflict(BaseModel):
+    """
+    """
+    pass