quantum-framework 0.18.0__tar.gz → 0.20.0__tar.gz

{quantum_framework-0.18.0 → quantum_framework-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantum-framework
-Version: 0.18.0
+Version: 0.20.0
 Summary: Full-stack declarative framework for building web, desktop, and mobile applications
 Author-email: Daniel Gregorio <danielgregorio2611@gmail.com>
 License: MIT
@@ -94,7 +94,7 @@ and asks the model — in the markup. There is no Python file behind it.
 An agent with its own tools, same idea:
 
 ```xml
-<q:agent name="calc" model="phi3" max_iterations="4">
+<q:agent name="calc" model="phi3" maxIterations="4">
   <q:instruction>Use the add tool, then answer.</q:instruction>
 
   <q:tool name="add" description="Add two numbers">

{quantum_framework-0.18.0 → quantum_framework-0.20.0}/README.md

@@ -44,7 +44,7 @@ and asks the model — in the markup. There is no Python file behind it.
 An agent with its own tools, same idea:
 
 ```xml
-<q:agent name="calc" model="phi3" max_iterations="4">
+<q:agent name="calc" model="phi3" maxIterations="4">
   <q:instruction>Use the add tool, then answer.</q:instruction>
 
   <q:tool name="add" description="Add two numbers">

{quantum_framework-0.18.0 → quantum_framework-0.20.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quantum-framework"
-version = "0.18.0"
+version = "0.20.0"
 description = "Full-stack declarative framework for building web, desktop, and mobile applications"
 readme = "README.md"
 license = {text = "MIT"}

{quantum_framework-0.18.0 → quantum_framework-0.20.0}/quantum/cli/runner.py

@@ -399,6 +399,15 @@ Examples:
     migrate_create_parser = migrate_subparsers.add_parser('create', help='Create a new migration')
     migrate_create_parser.add_argument('name', help='Migration name')
 
+    # M6 (DB-10): schema.sql as the source of truth
+    migrate_plan_parser = migrate_subparsers.add_parser(
+        'plan', help='Compare schema.sql with the migrations and plan the migration')
+    migrate_plan_parser.add_argument('--schema', default='schema.sql', help='Schema file (default: schema.sql)')
+    migrate_plan_parser.add_argument('--write', metavar='NAME', help='Save the plan as migration V00N_NAME')
+    migrate_plan_parser.add_argument('--yes', action='store_true', help='Do not ask before writing')
+    migrate_plan_parser.add_argument('--allow-data-loss', action='store_true',
+                                     help='Write a plan that drops tables or columns')
+
     # Parse arguments
     args = parser.parse_args()
 
@@ -541,13 +550,18 @@ Examples:
                 if failed:
                     sys.exit(1)
 
+            elif args.migrate_command == 'plan':
+                from quantum.cli.schema_plan import run_plan
+                sys.exit(run_plan(Path.cwd(), args.schema, args.write, args.yes, args.allow_data_loss,
+                                  interactive=sys.stdin.isatty()))
+
             elif args.migrate_command == 'create':
                 filepath = runner.create(args.name)
                 print(f"Created migration: {filepath}")
                 print(f"Also created rollback: {filepath.with_suffix('.down.sql')}")
 
             else:
-                print("Usage: quantum migrate <status|up|down|create> [options]")
+                print("Usage: quantum migrate <status|up|down|create|plan> [options]")
                 sys.exit(1)
 
             sys.exit(0)

quantum_framework-0.20.0/quantum/cli/schema_plan.py

@@ -0,0 +1,273 @@
+"""`quantum migrate plan`: a declarative schema (M6, DB-10).
+
+You edit `schema.sql` — the tables as they should be. `quantum migrate plan`
+compares it with the schema the migrations produce, shows what changes, marks
+what loses data, and `--write` saves the migration (and its rollback) after
+confirmation. `quantum migrate up` applies it as any other.
+
+Both sides are built in in-memory SQLite databases — the migrations applied in
+order, and schema.sql — and compared with the schema reader of `quantum check`
+(quantum/runtime/db_schema.py). The development database is not read: the
+plan is the same on any machine and in CI.
+
+SQLite can add a column but not change one, so any other change to a table
+rebuilds it: create the new table, copy the columns both have, drop the old,
+rename. Before a plan is written it is checked: applied to the migrations'
+schema it must produce exactly schema.sql's.
+"""
+
+import re
+import sqlite3
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+from quantum.runtime.db_schema import Column, read_schema
+
+# Tables that belong to Quantum, not to the app's schema.
+INTERNAL_TABLES = {'_migrations', 'quantum_history'}
+
+
+class SchemaPlanError(Exception):
+    """The plan cannot be made (no schema.sql, invalid SQL, a change it cannot express)."""
+
+
+@dataclass
+class Step:
+    kind: str                 # add-table, drop-table, add-column, rebuild, add-index, drop-index
+    target: str               # "posts" or "posts.summary"
+    detail: str = ''
+    sql: List[str] = field(default_factory=list)
+    loses_data: bool = False
+    warning: str = ''
+
+    def line(self) -> str:
+        mark = {'add-table': '+', 'add-column': '+', 'add-index': '+', 'drop-table': '-',
+                'drop-index': '-', 'rebuild': '~'}.get(self.kind, '?')
+        text = f'{mark} {self.kind.replace("-", " ")} {self.target}'
+        if self.detail:
+            text += f' ({self.detail})'
+        if self.loses_data:
+            text += '  !! loses data'
+        if self.warning:
+            text += f'  !! {self.warning}'
+        return text
+
+
+def _database(scripts: List[Tuple[str, str]]) -> sqlite3.Connection:
+    conn = sqlite3.connect(':memory:')
+    for origin, sql in scripts:
+        try:
+            conn.executescript(sql)
+        except sqlite3.Error as exc:
+            raise SchemaPlanError(f'{origin}: {exc}') from exc
+    return conn
+
+
+def _migration_scripts(migrations_dir: Path) -> List[Tuple[str, str]]:
+    if not migrations_dir.exists():
+        return []
+    files = [f for f in sorted(migrations_dir.glob('*.sql')) if not f.name.endswith('.down.sql')]
+    return [(f.name, f.read_text(encoding='utf-8')) for f in files if '_' in f.stem]
+
+
+def _tables(conn) -> Dict[str, object]:
+    return {name: t for name, t in read_schema(conn).items() if name not in INTERNAL_TABLES}
+
+
+def _create_sql(conn, table: str) -> str:
+    return conn.execute("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?",
+                        (table,)).fetchone()[0]
+
+
+def _indexes(conn) -> Dict[str, Tuple[str, str]]:
+    """Explicit indexes: name -> (table, sql)."""
+    return {name: (table, sql) for name, table, sql in conn.execute(
+        "SELECT name, tbl_name, sql FROM sqlite_master WHERE type = 'index' AND sql IS NOT NULL")
+        if table not in INTERNAL_TABLES}
+
+
+def _column_sql(column: Column) -> str:
+    parts = [f'"{column.name}"']
+    if column.type:
+        parts.append(column.type)
+    if column.not_null:
+        parts.append('NOT NULL')
+    if column.default is not None:
+        parts.append(f'DEFAULT {column.default}')
+    if column.options:
+        options = ', '.join("'" + o.replace("'", "''") + "'" for o in column.options)
+        parts.append(f'CHECK ("{column.name}" IN ({options}))')
+    if column.references:
+        parts.append(f'REFERENCES "{column.references[0]}"("{column.references[1]}")')
+    return ' '.join(parts)
+
+
+def _differences(a: Column, b: Column) -> List[str]:
+    changed = []
+    for label, x, y in (('type', (a.type or '').upper(), (b.type or '').upper()),
+                        ('NOT NULL', a.not_null, b.not_null), ('default', a.default, b.default),
+                        ('primary key', a.primary_key, b.primary_key), ('CHECK', a.options, b.options),
+                        ('references', a.references, b.references)):
+        if x != y:
+            changed.append(label)
+    return changed
+
+
+def diff(current_db, desired_db) -> List[Step]:
+    """The steps that turn the first database's schema into the second's."""
+    current, desired = _tables(current_db), _tables(desired_db)
+    steps: List[Step] = []
+    rebuilt = set()
+
+    for name in sorted(set(desired) - set(current)):
+        steps.append(Step('add-table', name, sql=[_create_sql(desired_db, name) + ';']))
+
+    for name in sorted(set(current) & set(desired)):
+        before, after = current[name].columns, desired[name].columns
+        added = [c for c in after if c not in before]
+        removed = [c for c in before if c not in after]
+        changed = {c: _differences(before[c], after[c]) for c in before
+                   if c in after and _differences(before[c], after[c])}
+        addable = all(not after[c].primary_key and (not after[c].not_null or after[c].default is not None)
+                      for c in added)
+        if not removed and not changed and addable:
+            for c in added:
+                steps.append(Step('add-column', f'{name}.{c}', after[c].type or '',
+                                  [f'ALTER TABLE "{name}" ADD COLUMN {_column_sql(after[c])};']))
+            continue
+        if not (added or removed or changed):
+            continue
+        common = ', '.join(f'"{c}"' for c in after if c in before)
+        create = re.sub(r'^\s*CREATE\s+TABLE\s+("?)' + re.escape(name) + r'\1',
+                        f'CREATE TABLE "{name}__new"', _create_sql(desired_db, name), count=1, flags=re.I)
+        details = [f'+ {c}' for c in added] + [f'- {c}' for c in removed] + \
+                  [f'{c}: {", ".join(d)}' for c, d in changed.items()]
+        warning = ''
+        if any('NOT NULL' in d and after[c].not_null for c, d in changed.items()) or \
+                any(after[c].not_null and after[c].default is None for c in added):
+            warning = 'fails if existing rows have no value for a NOT NULL column'
+        steps.append(Step('rebuild', name, '; '.join(details), [
+            create + ';',
+            f'INSERT INTO "{name}__new" ({common}) SELECT {common} FROM "{name}";',
+            f'DROP TABLE "{name}";',
+            f'ALTER TABLE "{name}__new" RENAME TO "{name}";',
+        ], loses_data=bool(removed) or any('type' in d for d in changed.values()), warning=warning))
+        rebuilt.add(name)
+
+    for name in sorted(set(current) - set(desired)):
+        steps.append(Step('drop-table', name, sql=[f'DROP TABLE "{name}";'], loses_data=True))
+
+    # Indexes: a rebuilt table lost its own, so they are created again.
+    before_idx, after_idx = _indexes(current_db), _indexes(desired_db)
+    for name, (table, sql) in sorted(before_idx.items()):
+        if table in desired and table not in rebuilt and after_idx.get(name, (None, None))[1] != sql:
+            steps.append(Step('drop-index', name, sql=[f'DROP INDEX "{name}";']))
+    for name, (table, sql) in sorted(after_idx.items()):
+        if before_idx.get(name, (None, None))[1] != sql or table in rebuilt:
+            steps.append(Step('add-index', name, sql=[sql + ';']))
+    return steps
+
+
+def _schema_only(conn) -> str:
+    """The CREATE statements of a database, tables before indexes, without its rows."""
+    rows = conn.execute("SELECT type, sql FROM sqlite_master WHERE sql IS NOT NULL "
+                        "AND name NOT LIKE 'sqlite_%' ORDER BY type = 'index', rowid").fetchall()
+    return '\n'.join(sql + ';' for _type, sql in rows)
+
+
+def _signature(conn) -> tuple:
+    tables = _tables(conn)
+    return (tuple(sorted((n, tuple(sorted((c.name, (c.type or '').upper(), c.not_null, c.default, c.primary_key,
+                                              tuple(c.options or ()), c.references)
+                                             for c in t.columns.values()))) for n, t in tables.items())),
+            tuple(sorted((n, s) for n, (_t, s) in _indexes(conn).items())))
+
+
+@dataclass
+class Plan:
+    steps: List[Step]
+    up_sql: str
+    down_sql: str
+
+    @property
+    def loses_data(self) -> bool:
+        return any(s.loses_data for s in self.steps)
+
+
+def make_plan(schema_file: Path, migrations_dir: Path) -> Plan:
+    if not schema_file.exists():
+        raise SchemaPlanError(f'{schema_file} does not exist: write the tables as they should be, '
+                              f'e.g. CREATE TABLE posts (id INTEGER PRIMARY KEY, title TEXT NOT NULL);')
+    migrations = _migration_scripts(migrations_dir)
+    current = _database(migrations)
+    desired = _database([(schema_file.name, schema_file.read_text(encoding='utf-8'))])
+    steps = diff(current, desired)
+    up = '\n'.join(s for step in steps for s in step.sql)
+    down = '\n'.join(s for step in diff(desired, current) for s in step.sql)
+    if steps:
+        # The plan must do what it says: applied, it yields schema.sql's schema.
+        # Checked on the structure only — what existing rows may break is the
+        # step's warning, shown in the plan, not a reason to hide the plan.
+        check = _database([('migrations (schema only)', _schema_only(current)), ('plan', up)])
+        if _signature(check) != _signature(desired):
+            raise SchemaPlanError('the generated migration does not reproduce schema.sql — '
+                                  'write this change as a migration by hand (quantum migrate create)')
+    return Plan(steps, up, down)
+
+
+def next_version(migrations_dir: Path) -> str:
+    numbers = [int(m.group(1)) for f in migrations_dir.glob('V*.sql')
+               for m in [re.match(r'V(\d+)_', f.name)] if m]
+    return f'V{(max(numbers) + 1 if numbers else 1):03d}'
+
+
+def write_plan(plan: Plan, migrations_dir: Path, name: str) -> Path:
+    migrations_dir.mkdir(parents=True, exist_ok=True)
+    slug = re.sub(r'[^a-z0-9_]+', '_', name.lower()).strip('_') or 'schema'
+    version = next_version(migrations_dir)
+    path = migrations_dir / f'{version}_{slug}.sql'
+    header = '-- Generated by `quantum migrate plan` from schema.sql (DB-10)\n'
+    summary = '\n'.join(f'-- {s.line()}' for s in plan.steps)
+    path.write_text(f'{header}{summary}\n\n{plan.up_sql}\n', encoding='utf-8')
+    (migrations_dir / f'{version}_{slug}.down.sql').write_text(
+        f'{header}-- rollback\n\n{plan.down_sql}\n', encoding='utf-8')
+    return path
+
+
+def run_plan(project: Path, schema: Optional[str], write: Optional[str], yes: bool,
+             allow_data_loss: bool, ask=input, interactive: bool = True) -> int:
+    """The `quantum migrate plan` command. Returns the exit code."""
+    from quantum.cli.commands.migrate import _paths_migrations
+    migrations_dir = project / _paths_migrations(project)
+    schema_file = project / (schema or 'schema.sql')
+    try:
+        plan = make_plan(schema_file, migrations_dir)
+    except SchemaPlanError as exc:
+        print(f'[ERROR] {exc}')
+        return 1
+    if not plan.steps:
+        print(f'Nothing to do: the migrations already produce {schema_file.name}.')
+        return 0
+    print(f'Plan: {schema_file.name} vs. the migrations in {migrations_dir.name}/\n')
+    for step in plan.steps:
+        print('  ' + step.line())
+    print('\nSQL:\n' + plan.up_sql)
+    if not write:
+        print('\nNothing written. `quantum migrate plan --write <name>` saves it as a migration.')
+        return 0
+    if plan.loses_data and not allow_data_loss:
+        print('\n[REFUSED] This plan loses data (marked !!). Check it, then run again with '
+              '--allow-data-loss.')
+        return 1
+    if not yes:
+        if not interactive:
+            print('\n[REFUSED] Confirm with --yes (not a terminal: nobody to ask).')
+            return 1
+        answer = ask(f'\nWrite migration {next_version(migrations_dir)}_{write}? [y/N] ').strip().lower()
+        if answer not in ('y', 'yes'):
+            print('Nothing written.')
+            return 1
+    path = write_plan(plan, migrations_dir, write)
+    print(f'Written: {path} (and {path.stem}.down.sql). Apply with `quantum migrate up`.')
+    return 0

{quantum_framework-0.18.0 → quantum_framework-0.20.0}/quantum/core/ast_nodes.py

@@ -699,6 +699,7 @@ class QueryNode(QuantumNode):
         self.paginate = False  # Enable automatic pagination
         self.page = None
         self.page_expr = None  # DB-9: page as an expression (default {query.page})
+        self.on_error = 'fail'  # IA-5: 'continue' hands a failure to <name>_result
         self.sortable = False  # UI-13: ORDER BY the URL's ?sort=/&dir=
         self.page_size = 20
         self.timeout = None
@@ -1478,6 +1479,10 @@ class LLMNode(QuantumNode):
         self.prompt = None              # Prompt text (with databinding)
         self.system = None              # System prompt (optional)
         self.messages: List[LLMMessageNode] = []  # Chat mode messages
+        self.on_error = 'fail'          # IA-5: 'continue' hands a failure to <name>_result
+        self.knowledge = None           # IA-6: answer from this knowledge base, citing sources
+        self.top = 4                    # IA-6: how many sources to retrieve
+        self.stream = False             # IA-7: stream the answer to <ui:stream> (web requests)
         self.temperature = None         # 0.0-2.0
         self.max_tokens = None          # Token limit
         self.response_format = None     # "text" or "json"

{quantum_framework-0.18.0 → quantum_framework-0.20.0}/quantum/core/expression_stdlib.py

@@ -172,6 +172,12 @@ def verify_password(password: Any, hashed: Any) -> bool:
         return False
 
 
+def _urlencode(v) -> str:
+    """EXPR-12: a value made safe to put in a URL — `q:redirect url="/?q={urlencode(q)}"`."""
+    from urllib.parse import quote_plus
+    return quote_plus('' if v is None else str(v))
+
+
 STDLIB = {
     # passwords
     'hashPassword': hash_password,
@@ -189,6 +195,7 @@ STDLIB = {
     'split': _split,
     'contains': _contains,
     'slugify': _slugify,
+    'urlencode': _urlencode,
     # collections
     'len': _len,
     'first': _first,

{quantum_framework-0.18.0 → quantum_framework-0.20.0}/quantum/core/features/agents/src/ast_node.py

@@ -290,7 +290,7 @@ class AgentNode(QuantumNode):
 
     Example:
         <!-- Using Ollama (default) -->
-        <q:agent name="support" model="phi3" max_iterations="5">
+        <q:agent name="support" model="phi3" maxIterations="5">
             ...
         </q:agent>
 
@@ -319,6 +319,7 @@ class AgentNode(QuantumNode):
     api_key: str = ""  # For cloud providers
     max_iterations: int = 10
     timeout: int = 60000  # milliseconds
+    on_error: str = "fail"  # IA-5: "continue" hands a failure to the page
 
     instruction: Optional[AgentInstructionNode] = None
     tools: List[AgentToolNode] = field(default_factory=list)

{quantum_framework-0.18.0 → quantum_framework-0.20.0}/quantum/core/features/knowledge_base/src/ast_node.py

@@ -82,6 +82,7 @@ class KnowledgeNode(QuantumNode):
     persist: bool = False                     # Persist ChromaDB to disk
     persist_path: Optional[str] = None        # ChromaDB persistence path
     rebuild: bool = False                     # Force reindex
+    on_error: str = 'fail'                    # IA-5: 'continue' hands a failure to <name>_info
 
     def add_source(self, source: KnowledgeSourceNode):
         self.sources.append(source)

{quantum_framework-0.18.0 → quantum_framework-0.20.0}/quantum/core/features/ui_engine/src/ast_nodes.py

@@ -1896,6 +1896,39 @@ class UIPagerNode(QuantumNode, UILayoutMixin):
         return [] if self.for_query else ["ui:pager needs for="]
 
 
+class UIStreamNode(QuantumNode, UILayoutMixin):
+    """<ui:stream for="answer"> — a q:llm answer, arriving as it is written (IA-7)."""
+
+    def __init__(self):
+        self.for_llm: Optional[str] = None
+        self.children: List[QuantumNode] = []
+        self._init_layout_attrs()
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"type": "ui_stream", "for": self.for_llm}
+
+    def validate(self) -> List[str]:
+        return []
+
+
+class UIHistoryNode(QuantumNode, UILayoutMixin):
+    """<ui:history table="t" key="{row.id}" datasource="db"> — a row's change history (DB-11)."""
+
+    def __init__(self):
+        self.table: Optional[str] = None
+        self.key: Optional[str] = None
+        self.datasource: Optional[str] = None
+        self.limit: int = 50
+        self.children: List[QuantumNode] = []
+        self._init_layout_attrs()
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"type": "ui_history", "table": self.table, "key": self.key}
+
+    def validate(self) -> List[str]:
+        return []
+
+
 def is_ui_node(node) -> bool:
     """A ui:* element (UI-1): markup, drawn by a renderer, never executed."""
     return type(node).__module__ == __name__
@@ -1908,6 +1941,6 @@ CORE_TAGS = frozenset({
     'window', 'hbox', 'vbox', 'grid', 'panel', 'section', 'scrollbox', 'spacer', 'rule',
     'header', 'footer', 'card', 'card-header', 'card-body', 'card-footer', 'tabpanel', 'tab',
     'text', 'badge', 'alert', 'link', 'image', 'progress',
-    'table', 'column', 'list', 'item', 'pager',
+    'table', 'column', 'list', 'item', 'pager', 'history', 'stream',
     'form', 'formitem', 'input', 'checkbox', 'switch', 'radio', 'select', 'option', 'button',
 })

{quantum_framework-0.18.0 → quantum_framework-0.20.0}/quantum/core/features/ui_engine/src/parser.py

@@ -28,7 +28,7 @@ from .ast_nodes import (
     UIToastNode, UIToastContainerNode,
     UICarouselNode, UISlideNode,
     UIStepperNode, UIStepNode,
-    UICalendarNode, UIDatePickerNode, UIPagerNode,
+    UICalendarNode, UIDatePickerNode, UIPagerNode, UIHistoryNode, UIStreamNode,
 )
 from quantum.core.features.theming.src import UIThemeNode, UIColorNode
 from quantum.core.ast_nodes import TextNode
@@ -82,6 +82,8 @@ class UIParser:
         'table': '_parse_ui_table',
         'column': '_parse_ui_column',
         'pager': '_parse_ui_pager',
+        'history': '_parse_ui_history',
+        'stream': '_parse_ui_stream',
         'list': '_parse_ui_list',
         'item': '_parse_ui_item',
         'image': '_parse_ui_image',
@@ -550,6 +552,29 @@ class UIParser:
         self._apply_layout_attrs(node, element)
         return node
 
+    def _parse_ui_stream(self, element: ET.Element) -> UIStreamNode:
+        node = UIStreamNode()
+        node.for_llm = element.get('for')
+        if not node.for_llm:
+            raise UIParseError('<ui:stream> needs for="<the q:llm name>"')
+        self._apply_layout_attrs(node, element)
+        return node
+
+    def _parse_ui_history(self, element: ET.Element) -> UIHistoryNode:
+        node = UIHistoryNode()
+        node.table = element.get('table')
+        node.key = element.get('key')
+        node.datasource = element.get('datasource')
+        missing = [a for a in ('table', 'key', 'datasource') if not element.get(a)]
+        if missing:
+            raise UIParseError(f'<ui:history> needs {", ".join(a + "=" for a in missing)}')
+        limit = element.get('limit')
+        if limit is not None and not limit.isdigit():
+            raise UIParseError(f'<ui:history limit="{limit}">: a number of entries')
+        node.limit = int(limit) if limit is not None else 50
+        self._apply_layout_attrs(node, element)
+        return node
+
     def _parse_ui_list(self, element: ET.Element) -> UIListNode:
         node = UIListNode()
         node.source = element.get('source')

{quantum_framework-0.18.0 → quantum_framework-0.20.0}/quantum/core/parser.py

@@ -480,7 +480,13 @@ class QuantumParser:
         A direct else child of a q:if is already the nested form and stays
         where it is. An else with no q:if right before it is an error.
         """
-        for parent in list(root.iter()):
+        parents = list(root.iter())
+        # IF-4 looks at the else children as written: before any sibling-form
+        # else is moved into its q:if below (which is not ambiguous).
+        for parent in parents:
+            if self._get_element_name(parent) == 'if':
+                self._check_dangling_else(parent)
+        for parent in parents:
             if self._get_element_name(parent) == 'if':
                 continue
             anterior = None
@@ -502,6 +508,27 @@ class QuantumParser:
                     continue
                 anterior = child if nome == 'if' and self._is_quantum_tag(child) else None
 
+    def _check_dangling_else(self, if_element: ET.Element) -> None:
+        """IF-4: inside a q:if, a q:else/q:elseif right after an inner </q:if> is ambiguous.
+
+        IF-1 gives it to the outer q:if (a direct child belongs to its if), but
+        written right after an inner if it reads as that if's else — the
+        sibling form. A page built that way drew the else branch of the inner
+        if when the OUTER condition was false. Refused, with both fixes."""
+        previous = None
+        for child in if_element:
+            if not isinstance(child.tag, str):
+                continue
+            name = self._get_element_name(child)
+            if (name in ('else', 'elseif') and self._is_quantum_tag(child) and previous is not None):
+                error = QuantumParseError(
+                    f"<q:{name}> right after an inner </q:if>, inside another <q:if>, is ambiguous "
+                    f"(IF-4): it would belong to the OUTER q:if (IF-1). If it is the inner q:if's, "
+                    f"write it inside that q:if; if it is the outer's, put it before the inner q:if.")
+                error.line = getattr(child, 'sourceline', None)
+                raise error
+            previous = child if name == 'if' and self._is_quantum_tag(child) else None
+
     # Tags that existed and were removed, with what to use instead.
     REMOVED_TAGS = {
         'persist': ('was removed in Quantum 0.16 (SET-2): it kept variables in the browser, '

{quantum_framework-0.18.0 → quantum_framework-0.20.0}/quantum/core/parsers/ai/agent_parser.py

@@ -42,6 +42,15 @@ class AgentParser(BaseTagParser):
 
         if not name:
             raise ParserError("Agent requires 'name' attribute")
+        if element.get('max_iterations') is not None:
+            # The guide and the README wrote max_iterations; it was never read
+            # and every agent ran up to 10 steps.
+            raise ParserError(f'<q:agent name="{name}">: the attribute is maxIterations, '
+                              f'not max_iterations')
+        on_error = self.get_attr(element, 'onerror', 'fail')
+        if on_error not in ('fail', 'continue'):
+            raise ParserError(f'<q:agent name="{name}"> onerror must be "fail" or "continue", '
+                              f'not "{on_error}"')
 
         agent_node = AgentNode(
             name=name,
@@ -50,7 +59,8 @@ class AgentParser(BaseTagParser):
             provider=self.get_attr(element, 'provider', 'auto'),
             api_key=self.get_attr(element, 'apiKey', ''),
             max_iterations=self.get_int_attr(element, 'maxIterations', 10),
-            timeout=self.get_int_attr(element, 'timeout', 60000)
+            timeout=self.get_int_attr(element, 'timeout', 60000),
+            on_error=on_error,
         )
 
         # Parse children

{quantum_framework-0.18.0 → quantum_framework-0.20.0}/quantum/core/parsers/ai/knowledge_parser.py

@@ -52,6 +52,11 @@ class KnowledgeParser(BaseTagParser):
             persist_path=self.get_attr(element, 'persistPath', './.quantum/knowledge'),
             rebuild=self.get_bool_attr(element, 'rebuild', False)
         )
+        # IA-5: a base that cannot be built stops the page unless the page handles it.
+        knowledge_node.on_error = self.get_attr(element, 'onerror', 'fail')
+        if knowledge_node.on_error not in ('fail', 'continue'):
+            raise ParserError(f'<q:knowledge name="{name}"> onerror must be "fail" or "continue", '
+                              f'not "{knowledge_node.on_error}"')
 
         # Parse sources
         for child in element:
@@ -66,6 +71,11 @@ class KnowledgeParser(BaseTagParser):
     def _parse_source(self, element: ET.Element) -> KnowledgeSourceNode:
         """Parse q:source within q:knowledge."""
         source_type = self.get_attr(element, 'type', 'text')
+        # IA-8: type="url" was accepted and read nothing (a log line said "not
+        # yet implemented"); an unknown type read nothing at all.
+        if source_type not in ('text', 'file', 'directory', 'query'):
+            raise ParserError(f'<q:source type="{source_type}">: use text, file, directory or query'
+                              + (' (url is not supported)' if source_type == 'url' else ''))
 
         source = KnowledgeSourceNode(
             source_type=source_type,

{quantum_framework-0.18.0 → quantum_framework-0.20.0}/quantum/core/parsers/ai/llm_parser.py

@@ -60,7 +60,21 @@ class LLMParser(BaseTagParser):
         # same attributes now work on both tags.
         llm_node.provider = self.get_attr(element, 'provider')
         llm_node.api_key = self.get_attr(element, 'apiKey')
-        llm_node.timeout = self.get_int_attr(element, 'timeout', 30)
+        # Seconds to wait for the model; undeclared, the service default (60).
+        llm_node.timeout = self.get_int_attr(element, 'timeout', 0) or None
+        # M5 (IA-6): answer from a knowledge base, citing its sources.
+        llm_node.knowledge = self.get_attr(element, 'knowledge')
+        top = self.get_attr(element, 'top')
+        if top is not None and not str(top).isdigit():
+            raise ParserError(f'<q:llm name="{name}" top="{top}">: the number of sources to retrieve')
+        llm_node.top = int(top) if top is not None else 4
+        # IA-7: in a web request, the answer arrives as it is written (<ui:stream>).
+        llm_node.stream = self.get_bool_attr(element, 'stream', False)
+        # IA-5: a failure stops the page unless the page handles it.
+        llm_node.on_error = self.get_attr(element, 'onerror', 'fail')
+        if llm_node.on_error not in ('fail', 'continue'):
+            raise ParserError(f'<q:llm name="{name}"> onerror must be "fail" or "continue", '
+                              f'not "{llm_node.on_error}"')
 
         # Parse children
         for child in element:

{quantum_framework-0.18.0 → quantum_framework-0.20.0}/quantum/core/parsers/data/query_parser.py

@@ -108,6 +108,12 @@ class QueryParser(BaseTagParser):
             or None
         )
         query_node.result = self.get_attr(element, 'result')
+        # IA-5 / DB: onerror="continue" hands a failure to the page as <name>_result.
+        query_node.on_error = self.get_attr(element, 'onerror', 'fail')
+        if query_node.on_error not in ('fail', 'continue'):
+            from quantum.core.parser import QuantumParseError
+            raise QuantumParseError(f'<q:query name="{name}"> onerror must be "fail" or "continue", '
+                                    f'not "{query_node.on_error}"')
 
         # RAG/Knowledge attributes
         query_node.mode = self.get_attr(element, 'mode')

{quantum_framework-0.18.0 → quantum_framework-0.20.0}/quantum/runtime/action_handler.py

@@ -122,9 +122,12 @@ class ActionHandler:
                 context.set_variable(key, value)
 
             # 4. Execute action body
+            from quantum.runtime import history
+            history_token = history.enter(getattr(action, 'name', None), context.session_vars)   # M22
             try:
                 redirect_info = self._execute_action_body(action, context)
             finally:
+                history.leave(history_token)
                 # M12: the /_dev panel shows the action's variables (no-op off debug).
                 from quantum.runtime.dev_panel import note_scopes
                 note_scopes(context, 'action')