speclogician 0.0.0b1__tar.gz → 0.0.0.dev1__tar.gz

speclogician-0.0.0.dev1/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.3
+Name: speclogician
+Version: 0.0.0.dev1
+Summary: SpecLogicain AI framework for data-driven formal program specification synthesis, verification and analysis
+Author: denis, hongyu
+Author-email: denis <denis@imandra.ai>, hongyu <hongyu@imandra.ai>
+Requires-Dist: imandrax-api-models>=18.0.0
+Requires-Dist: iml-query>=0.5.1
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: rich>=14.2.0
+Requires-Dist: textual>=6.11.0
+Requires-Dist: typer>=0.20.0
+Requires-Python: >=3.12
+Project-URL: Homepage, https://speclogician.dev/
+Description-Content-Type: text/markdown
+
+# SpecLogician
+SpecLogicain AI framework for data-driven formal program specification synthesis, verification and analysis
+
+
+www.speclogician.dev

speclogician-0.0.0.dev1/README.md

@@ -0,0 +1,5 @@
+# SpecLogician
+SpecLogicain AI framework for data-driven formal program specification synthesis, verification and analysis
+
+
+www.speclogician.dev

{speclogician-0.0.0b1 → speclogician-0.0.0.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "speclogician"
-version = "0.0.0b1"
+version = "0.0.0.dev1"
 description = "SpecLogicain AI framework for data-driven formal program specification synthesis, verification and analysis"
 readme = "README.md"
 authors = [
@@ -21,12 +21,5 @@ dependencies = [
 requires = ["uv_build>=0.8.22,<0.9.0"]
 build-backend = "uv_build"
 
-[dependency-groups]
-dev = [
-    "dotenv>=0.9.9",
-    "pytest>=9.0.2",
-    "pytest-asyncio>=1.3.0",
-]
-
 [project.urls]
 Homepage = "https://speclogician.dev/"

speclogician-0.0.0.dev1/src/speclogician/agent/funcs.py

@@ -0,0 +1,29 @@
+#
+#   Imandra Inc.
+#
+#   agent.py
+#
+
+
+import sys
+from pathlib import Path
+
+from ..state.state import State
+from ..llms.llmtools import test_formalizer
+from ..llms.overlay import Overlay
+
+def process_test_file ( 
+        path : Path,
+        state : State,
+        overlay : Overlay
+    ) -> State:
+    """
+    Process a file state to the state
+    """
+
+    try:
+        tf = test_formalizer (str(path), overlay, state)
+    except Exception as e:
+        raise Exception (f"Failed to process test file: []")
+
+    return state.add_test_formalization(tf)

speclogician-0.0.0.dev1/src/speclogician/cmd/agent_cmd.py

@@ -0,0 +1,89 @@
+#
+#   Imandra Inc.
+#
+#   agent_cmd.py
+#
+
+import typer
+import os
+from pathlib import Path
+from typing import Annotated
+
+from rich.progress import track
+
+from ..llms.overlay import Overlays
+from ..agent.funcs import process_test_file
+from ..state.state import State
+from ..utils import console
+from ..utils.load import load_overlays, load_state
+
+app = typer.Typer()
+
+
+@app.command(help="Add a single file to the formalization state")
+def proc_test_file (
+        filepath : Annotated[str, typer.Argument()],
+        overlay_name : Annotated[str, typer.Argument(help="Overlay to use. It should also contain the file extension we'll use")]
+    ):
+
+    overlays = load_overlays()
+    state = load_state()
+    
+    tgt_path = Path(filepath).parent / filepath
+
+    overlay = overlays.get(overlay_name)
+    if overlay is None:
+        console.print(f":warning: Could not find an overlay named {overlay_name}!")
+        return
+    
+    try: 
+        process_test_file(tgt_path, state, overlay)
+    except Exception as e:
+        console.print(f"🛑 Caught an error when adding file: {e}")
+        return
+    
+    # Add the state definition here
+
+    typer.secho(f"✅ Successfully added {filepath} to the formalization state!")
+
+@app.command(help="Run full cycle formalization for a specified directory")
+def proc_test_dir (
+        dirpath : Annotated[str, typer.Argument(help="Target directory with tests that should be formalized")],
+        overlay_name : Annotated[str, typer.Argument(help="Overlay to use. It should also contain the file extension we'll use")],
+        clean : Annotated[bool, typer.Option(help="Should we override any tests from these files already present in the state?")] = False
+    ):
+    
+    state = load_state()
+
+    overlays = load_overlays()
+    overlay = overlays.get(overlay_name)
+
+    if overlay is None:
+        typer.secho(f"🛑 Could not find an overlay named {overlay_name}!", err=True)
+        return
+    
+    filepaths = os.listdir(dirpath)
+    filepaths = list(filter(lambda x: x.endswith(overlay.ext.strip()), filepaths))
+
+    console.print(f"Identified {len(filepaths)} to process")
+
+    count = 0
+
+    for i in track(range(len(filepaths)), description=f"Processing {dirpath}..."):
+
+        try:
+            process_test_file(Path(filepaths[i]), state, overlay)
+        except Exception as e:
+            console.print(f"Failed on {filepaths[i]}: {e}")
+
+        count += 1
+
+    console.print(f":robot:Processed {count} files!")
+
+    try:
+        state.save(dirpath)
+    except Exception as e:
+        typer.echo(f"🛑 Caught error when saving the formalization state: {e}")
+        return
+ 
+    typer.secho(f"✅ Successfully saved the formalization state to {dirpath}")

speclogician-0.0.0.dev1/src/speclogician/cmd/data_cmd.py

@@ -0,0 +1,24 @@
+#
+#   Imandra Inc.
+#
+#   data_cmd.py
+#   
+
+import typer
+from typing import Annotated
+
+app = typer.Typer()
+
+@app.command(name="list")
+def data_list():
+    """
+    List the available data sources
+    """
+    pass
+
+tests_app = typer.Typer()
+@tests_app.command(name="tests")
+def list (
+        max_num_tests : Annotated[int, typer.Argument(help="Maximum number of tests to displayed")]
+    ):
+    pass

speclogician-0.0.0.dev1/src/speclogician/cmd/model_cmd.py

@@ -0,0 +1,42 @@
+#   
+#   Imandra Inc.
+#
+#   model_cmd.py
+#
+
+import typer
+from typing import Annotated
+from rich.syntax import Syntax
+
+from ..utils import console
+from ..utils.load import load_state
+
+app = typer.Typer()
+
+@app.command(name="summary", help="")
+def summary():
+    """
+    """
+
+    state = load_state()
+
+    console.print(state.curr_state().model.report())
+
+@app.command(name="code", help="Generate the IML code for the Domain Model")
+def get_code(
+        filepath : Annotated[str|None, typer.Option(help="Output filepath")] = None
+    ):
+
+    state = load_state()
+
+    console.print(Syntax(state.curr_state().model.domain_model.to_iml(), "OCaml"))
+
+    if filepath is not None:
+        try:
+            with open(filepath, 'w') as outfile:
+                print(state.curr_state().model.domain_model.to_iml(), file=outfile)
+        except Exception as e:
+            console.print(f"🛑 Failed to write domain model to disk: {e}",)
+            return
+
+    console.print(f"✅ Successfully wrote domain model to disk: {filepath}")

speclogician-0.0.0.dev1/src/speclogician/cmd/overlay_cmd.py

@@ -0,0 +1,30 @@
+#
+#   Imandra Inc.
+#   
+#   overlay_cmd.py
+#
+
+from typing import Annotated
+from rich import print as printr
+import typer
+
+from ..utils.load import load_overlays
+
+app = typer.Typer()
+
+@app.command(name="list", help="list the available overlays")
+def list_():
+    overlays = load_overlays()
+    overlays.list_overlays()
+
+@app.command(name="view", help="View individual template")
+def view(
+        name : Annotated[str, typer.Argument(help="Name of the template to view")]
+    ):
+
+    overlays = load_overlays()
+    if name not in overlays.names():
+        typer.secho(f"🛑 No template with name {name} found!", err=True)
+        return
+    
+    printr(overlays.get(name))

speclogician-0.0.0.dev1/src/speclogician/cmd/scenario_cmd.py

@@ -0,0 +1,61 @@
+#
+#   Imandra Inc.
+#
+#   scenario_cmd.py
+#
+
+import typer
+
+from ..state.state import State
+from ..utils.load import load_state
+
+from typing import Annotated
+
+
+app = typer.Typer()
+
+@app.command(name="summary", help="Summary of the available scenarios")
+def summary():
+    """ 
+    """
+    
+    state = load_state()
+
+@app.command(name="view", help="View a specific scenario")
+def view(
+    sc_id : int,
+    scenario_name : str
+    ):
+    """
+    """
+    
+    state = load_state()
+
+@app.command(name="rm", help="Remove a scenario")
+def rm_scenario():
+    """ 
+    """
+    
+    state = load_state()
+
+@app.command(name="add", help="Add a scenario")
+def add_scenario(
+        name : Annotated[str, typer.Argument(help="Name to be given to the scenario, must be unique")] 
+    ):
+    """ 
+    """
+    state = load_state()
+
+@app.command(name="edit", help="Edit a scenario")
+def edit_scenario():
+    """ 
+    """
+    
+    state = load_state()
+
+@app.command(name="search", help="Search for a particular scenario by predicate/transition functions")
+def search(q : str):
+    """ 
+    """
+
+    state = load_state()

speclogician-0.0.0.dev1/src/speclogician/cmd/state_cmd.py

@@ -0,0 +1,52 @@
+#  
+#   Imandra Inc.
+#
+#   state_cmd.py
+#
+
+import typer
+import sys
+from typing import Annotated
+
+from ..state.state import State
+from ..utils import console
+from ..utils.load import load_state
+
+global state
+state : State
+
+app = typer.Typer()
+
+@app.command(name="list", help="List all state instances")
+def list_states (
+        max_num_states : Annotated[int, typer.Argument(help="Maximum number of states")]=10
+    ):
+    """ 
+    List the state instances
+    """
+    state = load_state()
+    console.print(state.inst_list())
+
+@app.command(name="set", help="Set current state to a specific idx in the list")
+def set (
+        state_idx : Annotated[int, typer.Argument(help="")]
+    ):
+
+    state = load_state()
+
+    try:
+        state.set_curr_state_idx (state_idx)
+    except Exception as e:
+        console.print(f"Caught error: {e}")
+        sys.exit(0)
+
+    console.print("Update current state idx to {state_idx}")
+
+@app.command(name="summary", help="Provide summary of the current state instance")
+def summary():
+    """
+    Provide a summary of the current state
+    """
+
+    state : State = load_state()
+    console.print(state.curr_state().report())

speclogician-0.0.0.dev1/src/speclogician/data/artifact.py

@@ -0,0 +1,21 @@
+#
+#   Imandra Inc.
+#
+#   artifact.py
+#
+
+import uuid
+from pydantic import BaseModel, Field
+
+class Artifact(BaseModel):
+    """
+    """
+    art_id : str = Field(default_factory=lambda: str(uuid.uuid4())) # assigned task ID, new one created if not provided
+
+class TraceArtifact(Artifact):
+    
+    given : str
+    when : str
+    then : str
+
+    valid_iml : bool = False

speclogician-0.0.0.dev1/src/speclogician/data/container.py

@@ -0,0 +1,36 @@
+#
+#   Imandra Inc.
+#
+#   container.py
+#
+
+from pydantic import BaseModel
+
+from .traces import TestTrace, LogTrace
+from .refs import DocRef, SrcCodeRef
+
+class ArtifactSummaryInfo(BaseModel):
+    """ """
+    pass
+
+class ArtifactContainer(BaseModel):
+    """ 
+    Artifact container
+    """
+
+    test_traces : list[TestTrace] = []
+    log_traces : list[LogTrace] = []
+    doc_ref : list[DocRef] = []
+    src_code : list[SrcCodeRef] = []
+
+
+    def info(self):
+        """
+        """
+
+        return {'hello': 123}
+
+    def add(self):
+        """ """
+        pass
+    

{speclogician-0.0.0b1 → speclogician-0.0.0.dev1}/src/speclogician/data/mapping.py

@@ -1,10 +1,11 @@
 #
 #   Imandra Inc.
 #
-#   speclogician/data/mapping.py
+#   mapping.py
 #
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
+from typing import Dict
 
 from enum import StrEnum
 
@@ -18,39 +19,39 @@ class ArtifactMap(BaseModel):
     handle potentially large datasets (e.g. massive logs)
     """
 
-    art_to_comp_map: dict[str, list[str]] = Field(default_factory=dict)
-    comp_to_art_map: dict[str, list[str]] = Field(default_factory=dict)
+    art_to_comp_map : Dict[str, list[str]] = {}
+    comp_to_art_map : Dict[str, list[str]] = {}
 
-    def add_connection (self, art_id : str, comp_name : str):
+    def add_connection (self, art_id : str, comp_id : str):
         """
         Add a link between artifact and model component
         """
         if art_id not in self.art_to_comp_map:
             self.art_to_comp_map[art_id] = []
         
-        if comp_name not in self.art_to_comp_map[art_id]:
-            self.art_to_comp_map[art_id].append(comp_name)
+        if comp_id not in self.art_to_comp_map[art_id]:
+            self.art_to_comp_map[art_id].append(comp_id)
 
-        if comp_name not in self.comp_to_art_map:
-            self.comp_to_art_map[comp_name] = []
+        if comp_id not in self.comp_to_art_map:
+            self.comp_to_art_map[comp_id] = []
         
-        if art_id not in self.comp_to_art_map[comp_name]:
-            self.comp_to_art_map[comp_name].append(art_id)        
+        if art_id not in self.comp_to_art_map[comp_id]:
+            self.comp_to_art_map[comp_id].append(art_id)        
 
-    def rem_connection (self, artifact_id : str, comp_name : str):
+    def rem_connection (self, artifact_id : str, comp_id : str):
         """
         Remove a connection
         """
 
         if artifact_id in self.art_to_comp_map:
-            if comp_name in self.art_to_comp_map[artifact_id]:
-                self.art_to_comp_map[artifact_id].remove(comp_name)
+            if comp_id in self.art_to_comp_map[artifact_id]:
+                self.art_to_comp_map[artifact_id].remove(comp_id)
         else:
             return False
 
-        if comp_name in self.comp_to_art_map:
-            if artifact_id in self.comp_to_art_map[comp_name]:
-                self.comp_to_art_map[comp_name].remove(artifact_id)
+        if comp_id in self.comp_to_art_map:
+            if artifact_id in self.comp_to_art_map[comp_id]:
+                self.comp_to_art_map[comp_id].remove(artifact_id)
     
     def rem_element (self, elem_type : ElementType, str_id : str):
         """

speclogician-0.0.0.dev1/src/speclogician/data/refs.py

@@ -0,0 +1,25 @@
+#
+#   Imandra Inc.
+#
+#   refs.py
+#
+
+from .artifact import Artifact
+
+class DocRef(Artifact):
+    """
+    Documentation reference
+    """
+    meta : str
+    text : str
+    
+class SrcCodeRef(Artifact):
+    """
+    Source code reference
+    """
+    
+    meta : str #
+    language : str #
+    file_path : str #
+    src_code : str #
+    iml_code : str # 

speclogician-0.0.0.dev1/src/speclogician/data/reports.py

@@ -0,0 +1,11 @@
+#
+#   Imandra Inc.
+#
+#   reports.py
+#
+
+from pydantic import BaseModel
+
+
+class TestFormalization(BaseModel):
+    pass

speclogician-0.0.0.dev1/src/speclogician/data/traces.py

@@ -0,0 +1,35 @@
+#
+#   Imandra Inc.
+#
+#   trace.py
+#
+
+from .artifact import TraceArtifact
+
+class TestTrace (TraceArtifact):
+    """
+    Test trace formalization
+    """    
+
+    name : str # Test case name
+    filepath : str # Original test filepath
+    language : str # Language of the original source code
+    contents : str # Original test contents
+    time : str # Time when this done
+
+    # Contain 
+
+class LogTrace(TraceArtifact):
+    """
+    Log tace formalization
+    """
+
+    filename : str # 
+    contents : str # Contents of the log entry
+
+    # Formalized entry
+    given : str
+    when : str
+    then : str
+
+    

speclogician-0.0.0.dev1/src/speclogician/llms/llmtools.py

@@ -0,0 +1,102 @@
+#
+#   Imandra Inc.
+#
+#   llmtools.py
+#
+
+import datetime, os, dotenv, sys, yaml, typer
+from typing import Optional
+from pathlib import Path
+from ..data.reports import TestFormalization
+from llms.overlay import Overlay
+
+#from langchain_anthropic import ChatAnthropic
+dotenv.load_dotenv("../.env")
+
+llm = None 
+
+#ChatAnthropic (
+#    model_name="claude-sonnet-4-20250514",
+#    api_key=os.environ["ANTHROPIC_API_KEY"],
+#)
+
+
+def test_formalizer (
+        filepath : str,
+        overlay : Overlay,
+        domain_model : Optional[str] = "N/A",
+        ) -> TestFormalization:
+    """
+    Returns a tuple of the logic and the type model
+    """
+    
+    test_case = Path(filepath).read_text()
+    try:
+        generic_prompt = Path("../prompts/generic.md").read_text()
+    except Exception as e:
+        print(f"Failed to load in the generic prompt: {e}")
+        sys.exit(0)
+
+    prompt = f"""
+{generic_prompt}
+
+{overlay}
+
+Domain model:
+----
+{domain_model}
+----
+
+Test case:
+----
+{test_case}
+----
+"""
+
+    structured_model = llm.with_structured_output(FormalizationResponse)
+
+    # Let's call the LLM
+    try: 
+        response : FormalizationResponse = structured_model.invoke(prompt)
+    except Exception as e:
+        typer.secho(f"Failed to make the LLM call: {e}", err=True)
+        sys.exit(0)
+
+    tf = TestFormalization(
+        name = response.test_name_str,
+        language = overlay.language,
+        filepath = filepath,
+        contents = test_case,
+        time = str(datetime.datetime.now()),
+        scenarios = response.scenarios,
+        domain_model = response.domain_model,
+    )
+
+    return tf
+
+def retry_test_formalization (
+        tf : TestFormalization,
+        model_response : str,
+    ) -> TestFormalization:
+    """
+    Make the call again to 
+    """
+
+    return tf
+
+if __name__ == "__main__":
+
+    base_dir = "../data/gherkin"
+    paths = os.listdir(base_dir)
+    overlay = Overlay.from_file("../overlays/gherkin.yaml")
+    domain_model : str = "N/A"
+    
+    responses : list[LLMResponse] = []
+
+    for path in paths:
+        r = test_formalizer(os.path.join(base_dir, paths[0]), overlay, domain_model)
+        responses.append(r)
+        domain_model = r.domain_model
+
+    for r in responses:
+        print (yaml.dump(r, default_flow_style=False))