namel3ss 0.1.0a0__py3-none-any.whl

namel3ss/format/rules.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import re
+from typing import List
+
+
+def migrate_buttons(lines: List[str]) -> List[str]:
+    migrated: List[str] = []
+    pattern = re.compile(r'(\s*)button\s+"([^"]+)"\s+calls\s+flow\s+"([^"]+)"\s*$', re.IGNORECASE)
+    for line in lines:
+        m = pattern.match(line)
+        if m:
+            indent = m.group(1)
+            label = m.group(2)
+            flow = m.group(3)
+            migrated.append(f'{indent}button "{label}":')
+            migrated.append(f"{indent}  calls flow \"{flow}\"")
+            continue
+        migrated.append(line)
+    return migrated
+
+
+def normalize_spacing(line: str) -> str:
+    indent_len = len(line) - len(line.lstrip(" "))
+    indent = " " * indent_len
+    rest = line.strip()
+    if rest == "":
+        return ""
+
+    # headers with names
+    m = re.match(r'^(flow|page|record|ai|agent|tool)\s+"([^"]+)"\s*:?\s*$', rest)
+    if m:
+        return f'{indent}{m.group(1)} "{m.group(2)}":'
+
+    if rest.startswith("button "):
+        m = re.match(r'^button\s+"([^"]+)"\s*:$', rest)
+        if m:
+            return f'{indent}button "{m.group(1)}":'
+
+    # property with "is"
+    m = re.match(r'^([A-Za-z_][A-Za-z0-9_]*)\s+is\s+(.+)$', rest)
+    if m:
+        rest = f"{m.group(1)} is {m.group(2)}"
+
+    # ask ai pattern
+    m = re.match(
+        r'^ask\s+ai\s+"([^"]+)"\s+with\s+input\s*:?\s*(.+?)\s+as\s+([A-Za-z_][A-Za-z0-9_]*)$',
+        rest,
+    )
+    if m:
+        rest = f'ask ai "{m.group(1)}" with input: {m.group(2)} as {m.group(3)}'
+
+    # calls flow line
+    m = re.match(r'^calls\s+flow\s+"([^"]+)"\s*$', rest)
+    if m:
+        rest = f'calls flow "{m.group(1)}"'
+
+    rest = re.sub(r'\s+:', ":", rest)
+    return f"{indent}{rest}"
+
+
+def normalize_indentation(lines: List[str]) -> List[str]:
+    result: List[str] = []
+    indent_stack = [0]
+    for line in lines:
+        if line.strip() == "":
+            result.append("")
+            continue
+        leading = len(line) - len(line.lstrip(" "))
+        if leading > indent_stack[-1]:
+            indent_stack.append(leading)
+        else:
+            while indent_stack and leading < indent_stack[-1]:
+                indent_stack.pop()
+            if leading != indent_stack[-1]:
+                indent_stack.append(leading)
+        depth = max(0, len(indent_stack) - 1)
+        content = line.lstrip(" ")
+        result.append("  " * depth + content)
+    return result
+
+
+def collapse_blank_lines(lines: List[str]) -> List[str]:
+    cleaned: List[str] = []
+    for line in lines:
+        if line.strip() == "":
+            if cleaned and cleaned[-1] == "":
+                continue
+            cleaned.append("")
+        else:
+            cleaned.append(line)
+    # trim leading/trailing blanks
+    while cleaned and cleaned[0] == "":
+        cleaned.pop(0)
+    while cleaned and cleaned[-1] == "":
+        cleaned.pop()
+    return cleaned

namel3ss/ir/__init__.py

@@ -0,0 +1,3 @@
+"""Intermediate representation for Namel3ss."""
+
+from namel3ss.ir.nodes import *  # noqa: F401,F403

namel3ss/ir/lowering/__init__.py

@@ -0,0 +1,4 @@
+from namel3ss.ir.lowering.program import lower_program
+from namel3ss.ir.lowering.flow import lower_flow
+
+__all__ = ["lower_program", "lower_flow"]

namel3ss/ir/lowering/agents.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import Dict, List
+
+from namel3ss.ast import nodes as ast
+from namel3ss.errors.base import Namel3ssError
+from namel3ss.ir.model.agents import AgentDecl, ParallelAgentEntry, RunAgentStmt, RunAgentsParallelStmt
+from namel3ss.ir.model.ai import AIDecl
+
+
+def _lower_agents(agents: List[ast.AgentDecl], ais: Dict[str, AIDecl]) -> Dict[str, AgentDecl]:
+    agent_map: Dict[str, AgentDecl] = {}
+    for agent in agents:
+        if agent.name in agent_map:
+            raise Namel3ssError(f"Duplicate agent declaration '{agent.name}'", line=agent.line, column=agent.column)
+        if agent.ai_name not in ais:
+            raise Namel3ssError(f"Agent '{agent.name}' references unknown AI '{agent.ai_name}'", line=agent.line, column=agent.column)
+        agent_map[agent.name] = AgentDecl(
+            name=agent.name,
+            ai_name=agent.ai_name,
+            system_prompt=agent.system_prompt,
+            line=agent.line,
+            column=agent.column,
+        )
+    return agent_map
+
+
+def _validate_agent_reference(agent_name: str, agents: Dict[str, AgentDecl], line, column) -> None:
+    if agent_name not in agents:
+        raise Namel3ssError(f"Unknown agent '{agent_name}'", line=line, column=column)
+
+
+def validate_agent_statement(stmt: RunAgentStmt | RunAgentsParallelStmt, agents: Dict[str, AgentDecl]) -> None:
+    if isinstance(stmt, RunAgentStmt):
+        _validate_agent_reference(stmt.agent_name, agents, stmt.line, stmt.column)
+        return
+    if isinstance(stmt, RunAgentsParallelStmt):
+        if not stmt.entries:
+            raise Namel3ssError("Parallel agent block requires at least one entry", line=stmt.line, column=stmt.column)
+        for entry in stmt.entries:
+            _validate_agent_reference(entry.agent_name, agents, entry.line, entry.column)
+        return

namel3ss/ir/lowering/ai.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from typing import Dict, List
+
+from namel3ss.ast import nodes as ast
+from namel3ss.errors.base import Namel3ssError
+from namel3ss.ir.model.ai import AIDecl, AIMemory
+from namel3ss.ir.model.tools import ToolDecl
+from namel3ss.runtime.ai.providers.registry import is_supported_provider
+
+
+def _lower_ai_decls(ais: List[ast.AIDecl], tools: Dict[str, ToolDecl]) -> Dict[str, AIDecl]:
+    ai_map: Dict[str, AIDecl] = {}
+    for ai in ais:
+        if ai.name in ai_map:
+            raise Namel3ssError(f"Duplicate AI declaration '{ai.name}'", line=ai.line, column=ai.column)
+        if not ai.model:
+            raise Namel3ssError(f"AI '{ai.name}' must specify a model", line=ai.line, column=ai.column)
+        provider = (ai.provider or "mock").lower()
+        if not is_supported_provider(provider):
+            raise Namel3ssError(f"Unknown AI provider '{provider}'", line=ai.line, column=ai.column)
+        exposed: List[str] = []
+        for tool in ai.exposed_tools:
+            if tool not in tools:
+                raise Namel3ssError(f"AI '{ai.name}' exposes unknown tool '{tool}'", line=ai.line, column=ai.column)
+            if tool in exposed:
+                raise Namel3ssError(f"Duplicate tool exposure '{tool}' in AI '{ai.name}'", line=ai.line, column=ai.column)
+            exposed.append(tool)
+        ai_map[ai.name] = AIDecl(
+            name=ai.name,
+            model=ai.model,
+            provider=provider,
+            system_prompt=ai.system_prompt,
+            exposed_tools=exposed,
+            memory=AIMemory(
+                short_term=ai.memory.short_term,
+                semantic=ai.memory.semantic,
+                profile=ai.memory.profile,
+                line=ai.memory.line,
+                column=ai.memory.column,
+            ),
+            line=ai.line,
+            column=ai.column,
+        )
+    return ai_map

namel3ss/ir/lowering/expressions.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from namel3ss.ast import nodes as ast
+from namel3ss.ir.model.expressions import AttrAccess, BinaryOp, Comparison, Literal, StatePath, UnaryOp, VarReference, Assignable
+
+
+def _lower_assignable(expr: ast.Assignable) -> Assignable:
+    if isinstance(expr, ast.VarReference):
+        return VarReference(name=expr.name, line=expr.line, column=expr.column)
+    if isinstance(expr, ast.StatePath):
+        return StatePath(path=list(expr.path), line=expr.line, column=expr.column)
+    raise TypeError(f"Unhandled assignable type: {type(expr)}")
+
+
+def _lower_expression(expr: ast.Expression | None):
+    if expr is None:
+        return None
+    if isinstance(expr, ast.Literal):
+        return Literal(value=expr.value, line=expr.line, column=expr.column)
+    if isinstance(expr, ast.VarReference):
+        return VarReference(name=expr.name, line=expr.line, column=expr.column)
+    if isinstance(expr, ast.AttrAccess):
+        return AttrAccess(base=expr.base, attrs=list(expr.attrs), line=expr.line, column=expr.column)
+    if isinstance(expr, ast.StatePath):
+        return StatePath(path=list(expr.path), line=expr.line, column=expr.column)
+    if isinstance(expr, ast.UnaryOp):
+        return UnaryOp(
+            op=expr.op,
+            operand=_lower_expression(expr.operand),
+            line=expr.line,
+            column=expr.column,
+        )
+    if isinstance(expr, ast.BinaryOp):
+        return BinaryOp(
+            op=expr.op,
+            left=_lower_expression(expr.left),
+            right=_lower_expression(expr.right),
+            line=expr.line,
+            column=expr.column,
+        )
+    if isinstance(expr, ast.Comparison):
+        return Comparison(
+            kind=expr.kind,
+            left=_lower_expression(expr.left),
+            right=_lower_expression(expr.right),
+            line=expr.line,
+            column=expr.column,
+        )
+    raise TypeError(f"Unhandled expression type: {type(expr)}")

namel3ss/ir/lowering/flow.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from namel3ss.ast import nodes as ast
+from namel3ss.ir.lowering.statements import _lower_statement
+from namel3ss.ir.model.agents import AgentDecl
+from namel3ss.ir.model.program import Flow
+from namel3ss.ir.lowering.agents import validate_agent_statement
+
+
+def lower_flow(flow: ast.Flow, agents: dict[str, AgentDecl]) -> Flow:
+    ir_body = []
+    for stmt in flow.body:
+        lowered = _lower_statement(stmt, agents)
+        validate_agent_statement(lowered, agents)
+        ir_body.append(lowered)
+    return Flow(
+        name=flow.name,
+        body=ir_body,
+        line=flow.line,
+        column=flow.column,
+    )

namel3ss/ir/lowering/pages.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from namel3ss.ast import nodes as ast
+from namel3ss.errors.base import Namel3ssError
+from namel3ss.ir.model.pages import ButtonItem, FormItem, Page, PageItem, TableItem, TextItem, TitleItem
+from namel3ss.schema import records as schema
+
+
+def _lower_page(page: ast.PageDecl, record_map: dict[str, schema.RecordSchema], flow_names: set[str]) -> Page:
+    items = [_lower_page_item(item, record_map, flow_names, page.name) for item in page.items]
+    return Page(name=page.name, items=items, line=page.line, column=page.column)
+
+
+def _lower_page_item(
+    item: ast.PageItem,
+    record_map: dict[str, schema.RecordSchema],
+    flow_names: set[str],
+    page_name: str,
+) -> PageItem:
+    if isinstance(item, ast.TitleItem):
+        return TitleItem(value=item.value, line=item.line, column=item.column)
+    if isinstance(item, ast.TextItem):
+        return TextItem(value=item.value, line=item.line, column=item.column)
+    if isinstance(item, ast.FormItem):
+        if item.record_name not in record_map:
+            raise Namel3ssError(
+                f"Page '{page_name}' references unknown record '{item.record_name}'",
+                line=item.line,
+                column=item.column,
+            )
+        return FormItem(record_name=item.record_name, line=item.line, column=item.column)
+    if isinstance(item, ast.TableItem):
+        if item.record_name not in record_map:
+            raise Namel3ssError(
+                f"Page '{page_name}' references unknown record '{item.record_name}'",
+                line=item.line,
+                column=item.column,
+            )
+        return TableItem(record_name=item.record_name, line=item.line, column=item.column)
+    if isinstance(item, ast.ButtonItem):
+        if item.flow_name not in flow_names:
+            raise Namel3ssError(
+                f"Page '{page_name}' references unknown flow '{item.flow_name}'",
+                line=item.line,
+                column=item.column,
+            )
+        return ButtonItem(label=item.label, flow_name=item.flow_name, line=item.line, column=item.column)
+    raise TypeError(f"Unhandled page item type: {type(item)}")

namel3ss/ir/lowering/program.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import Dict, List
+
+from namel3ss.ast import nodes as ast
+from namel3ss.ir.lowering.agents import _lower_agents
+from namel3ss.ir.lowering.ai import _lower_ai_decls
+from namel3ss.ir.lowering.flow import lower_flow
+from namel3ss.ir.lowering.pages import _lower_page
+from namel3ss.ir.lowering.records import _lower_record
+from namel3ss.ir.lowering.tools import _lower_tools
+from namel3ss.ir.model.program import Flow, Program
+from namel3ss.schema import records as schema
+
+
+def lower_program(program: ast.Program) -> Program:
+    record_schemas = [_lower_record(record) for record in program.records]
+    tool_map = _lower_tools(program.tools)
+    ai_map = _lower_ai_decls(program.ais, tool_map)
+    agent_map = _lower_agents(program.agents, ai_map)
+    flow_irs: List[Flow] = [lower_flow(flow, agent_map) for flow in program.flows]
+    record_map: Dict[str, schema.RecordSchema] = {rec.name: rec for rec in record_schemas}
+    flow_names = {flow.name for flow in flow_irs}
+    pages = [_lower_page(page, record_map, flow_names) for page in program.pages]
+    return Program(
+        records=record_schemas,
+        flows=flow_irs,
+        pages=pages,
+        ais=ai_map,
+        tools=tool_map,
+        agents=agent_map,
+        line=program.line,
+        column=program.column,
+    )

namel3ss/ir/lowering/records.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from namel3ss.ast import nodes as ast
+from namel3ss.ir.lowering.expressions import _lower_expression
+from namel3ss.schema import records as schema
+
+
+def _lower_record(record: ast.RecordDecl) -> schema.RecordSchema:
+    fields = []
+    for field in record.fields:
+        constraint = None
+        if field.constraint:
+            constraint = schema.FieldConstraint(
+                kind=field.constraint.kind,
+                expression=_lower_expression(field.constraint.expression) if field.constraint.expression else None,
+                pattern=field.constraint.pattern,
+            )
+        fields.append(
+            schema.FieldSchema(
+                name=field.name,
+                type_name=field.type_name,
+                constraint=constraint,
+            )
+        )
+    return schema.RecordSchema(name=record.name, fields=fields)

namel3ss/ir/lowering/statements.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+from namel3ss.ast import nodes as ast
+from namel3ss.ir.lowering.expressions import _lower_assignable, _lower_expression
+from namel3ss.ir.model.agents import ParallelAgentEntry, RunAgentStmt, RunAgentsParallelStmt
+from namel3ss.ir.model.ai import AskAIStmt
+from namel3ss.ir.model.statements import (
+    Find,
+    ForEach,
+    If,
+    Let,
+    Match,
+    MatchCase,
+    Repeat,
+    Return,
+    Save,
+    Set,
+    TryCatch,
+)
+from namel3ss.ir.model.statements import Statement as IRStatement
+
+
+def _lower_statement(stmt: ast.Statement, agents) -> IRStatement:
+    if isinstance(stmt, ast.Let):
+        return Let(
+            name=stmt.name,
+            expression=_lower_expression(stmt.expression),
+            constant=stmt.constant,
+            line=stmt.line,
+            column=stmt.column,
+        )
+    if isinstance(stmt, ast.Set):
+        return Set(
+            target=_lower_assignable(stmt.target),
+            expression=_lower_expression(stmt.expression),
+            line=stmt.line,
+            column=stmt.column,
+        )
+    if isinstance(stmt, ast.If):
+        return If(
+            condition=_lower_expression(stmt.condition),
+            then_body=[_lower_statement(s, agents) for s in stmt.then_body],
+            else_body=[_lower_statement(s, agents) for s in stmt.else_body],
+            line=stmt.line,
+            column=stmt.column,
+        )
+    if isinstance(stmt, ast.Return):
+        return Return(
+            expression=_lower_expression(stmt.expression),
+            line=stmt.line,
+            column=stmt.column,
+        )
+    if isinstance(stmt, ast.Repeat):
+        return Repeat(
+            count=_lower_expression(stmt.count),
+            body=[_lower_statement(s, agents) for s in stmt.body],
+            line=stmt.line,
+            column=stmt.column,
+        )
+    if isinstance(stmt, ast.ForEach):
+        return ForEach(
+            name=stmt.name,
+            iterable=_lower_expression(stmt.iterable),
+            body=[_lower_statement(s, agents) for s in stmt.body],
+            line=stmt.line,
+            column=stmt.column,
+        )
+    if isinstance(stmt, ast.AskAIStmt):
+        return AskAIStmt(
+            ai_name=stmt.ai_name,
+            input_expr=_lower_expression(stmt.input_expr),
+            target=stmt.target,
+            line=stmt.line,
+            column=stmt.column,
+        )
+    if isinstance(stmt, ast.Match):
+        return Match(
+            expression=_lower_expression(stmt.expression),
+            cases=[
+                MatchCase(
+                    pattern=_lower_expression(case.pattern),
+                    body=[_lower_statement(s, agents) for s in case.body],
+                    line=case.line,
+                    column=case.column,
+                )
+                for case in stmt.cases
+            ],
+            otherwise=[_lower_statement(s, agents) for s in stmt.otherwise] if stmt.otherwise is not None else None,
+            line=stmt.line,
+            column=stmt.column,
+        )
+    if isinstance(stmt, ast.TryCatch):
+        return TryCatch(
+            try_body=[_lower_statement(s, agents) for s in stmt.try_body],
+            catch_var=stmt.catch_var,
+            catch_body=[_lower_statement(s, agents) for s in stmt.catch_body],
+            line=stmt.line,
+            column=stmt.column,
+        )
+    if isinstance(stmt, ast.Save):
+        return Save(record_name=stmt.record_name, line=stmt.line, column=stmt.column)
+    if isinstance(stmt, ast.Find):
+        return Find(record_name=stmt.record_name, predicate=_lower_expression(stmt.predicate), line=stmt.line, column=stmt.column)
+    if isinstance(stmt, ast.RunAgentStmt):
+        return RunAgentStmt(
+            agent_name=stmt.agent_name,
+            input_expr=_lower_expression(stmt.input_expr),
+            target=stmt.target,
+            line=stmt.line,
+            column=stmt.column,
+        )
+    if isinstance(stmt, ast.RunAgentsParallelStmt):
+        return RunAgentsParallelStmt(
+            entries=[
+                ParallelAgentEntry(agent_name=e.agent_name, input_expr=_lower_expression(e.input_expr), line=e.line, column=e.column)
+                for e in stmt.entries
+            ],
+            target=stmt.target,
+            line=stmt.line,
+            column=stmt.column,
+        )
+    raise TypeError(f"Unhandled statement type: {type(stmt)}")

namel3ss/ir/lowering/tools.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from typing import Dict, List
+
+from namel3ss.ast import nodes as ast
+from namel3ss.errors.base import Namel3ssError
+from namel3ss.ir.model.tools import ToolDecl
+
+
+def _lower_tools(tools: List[ast.ToolDecl]) -> Dict[str, ToolDecl]:
+    tool_map: Dict[str, ToolDecl] = {}
+    for tool in tools:
+        if tool.name in tool_map:
+            raise Namel3ssError(f"Duplicate tool declaration '{tool.name}'", line=tool.line, column=tool.column)
+        tool_map[tool.name] = ToolDecl(name=tool.name, kind=tool.kind, line=tool.line, column=tool.column)
+    return tool_map

namel3ss/ir/model/__init__.py

@@ -0,0 +1,50 @@
+from namel3ss.ir.model.base import Expression, Node, Statement
+from namel3ss.ir.model.program import Flow, Program
+from namel3ss.ir.model.statements import ForEach, If, Let, Match, MatchCase, Repeat, Return, Save, Set, TryCatch, Find
+from namel3ss.ir.model.expressions import AttrAccess, BinaryOp, Comparison, Literal, StatePath, UnaryOp, VarReference, Assignable
+from namel3ss.ir.model.ai import AIDecl, AIMemory, AskAIStmt
+from namel3ss.ir.model.agents import AgentDecl, ParallelAgentEntry, RunAgentStmt, RunAgentsParallelStmt
+from namel3ss.ir.model.pages import ButtonItem, FormItem, Page, PageItem, TableItem, TextItem, TitleItem
+from namel3ss.ir.model.tools import ToolDecl
+
+__all__ = [
+    "Expression",
+    "Node",
+    "Statement",
+    "Flow",
+    "Program",
+    "ForEach",
+    "If",
+    "Let",
+    "Match",
+    "MatchCase",
+    "Repeat",
+    "Return",
+    "Save",
+    "Set",
+    "TryCatch",
+    "Find",
+    "AttrAccess",
+    "BinaryOp",
+    "Comparison",
+    "Literal",
+    "StatePath",
+    "UnaryOp",
+    "VarReference",
+    "Assignable",
+    "AIDecl",
+    "AIMemory",
+    "AskAIStmt",
+    "AgentDecl",
+    "ParallelAgentEntry",
+    "RunAgentStmt",
+    "RunAgentsParallelStmt",
+    "ButtonItem",
+    "FormItem",
+    "Page",
+    "PageItem",
+    "TableItem",
+    "TextItem",
+    "TitleItem",
+    "ToolDecl",
+]

namel3ss/ir/model/agents.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List, Optional
+
+from namel3ss.ir.model.base import Node, Statement
+from namel3ss.ir.model.expressions import Expression
+
+
+@dataclass
+class AgentDecl(Node):
+    name: str
+    ai_name: str
+    system_prompt: Optional[str]
+
+
+@dataclass
+class ParallelAgentEntry(Node):
+    agent_name: str
+    input_expr: Expression
+
+
+@dataclass
+class RunAgentStmt(Statement):
+    agent_name: str
+    input_expr: Expression
+    target: str
+
+
+@dataclass
+class RunAgentsParallelStmt(Statement):
+    entries: List[ParallelAgentEntry]
+    target: str

namel3ss/ir/model/ai.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List, Optional
+
+from namel3ss.ir.model.base import Node, Statement
+from namel3ss.ir.model.expressions import Expression
+
+
+@dataclass
+class AIMemory(Node):
+    short_term: int = 0
+    semantic: bool = False
+    profile: bool = False
+
+
+@dataclass
+class AIDecl(Node):
+    name: str
+    model: str
+    provider: str
+    system_prompt: Optional[str]
+    exposed_tools: List[str]
+    memory: AIMemory
+
+
+@dataclass
+class AskAIStmt(Statement):
+    ai_name: str
+    input_expr: Expression
+    target: str

namel3ss/ir/model/base.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class Node:
+    line: Optional[int]
+    column: Optional[int]
+
+
+@dataclass
+class Statement(Node):
+    pass
+
+
+@dataclass
+class Expression(Node):
+    pass