asecli 0.6.2__py3-none-any.whl

asecli/cli/recompile_metadata.py

@@ -0,0 +1,53 @@
+"""Preserve ASECLI property metadata across real ASE recompilation."""
+
+from __future__ import annotations
+
+import os
+
+from ..core import (
+    AseFile,
+    graph_custom_editor,
+    inspect_custom_gui,
+    MANAGED_PROPERTY_METADATA_ATTRIBUTE_TYPES,
+    resolve_property_node,
+    set_custom_editor,
+    set_property_metadata_attribute,
+    sync_compiled_property_metadata,
+)
+
+
+def snapshot_recompile_metadata(path: str) -> dict | None:
+    if not os.path.isfile(path):
+        return None
+    try:
+        ase_file = AseFile.from_path(path)
+        state = inspect_custom_gui(ase_file)
+    except (OSError, ValueError):
+        return None
+    properties = []
+    for prop in state["properties"]:
+        attributes = [
+            item["raw"] for item in prop["attributes"]
+            if item["type"] in MANAGED_PROPERTY_METADATA_ATTRIBUTE_TYPES
+        ]
+        if attributes:
+            properties.append({"name": prop["property_name"], "attributes": attributes})
+    editor = graph_custom_editor(ase_file.graph)
+    if not properties and editor is None:
+        return None
+    return {"editor": editor, "properties": properties}
+
+
+def restore_recompile_metadata(path: str, snapshot: dict) -> tuple[AseFile, int]:
+    ase_file = AseFile.from_path(path)
+    editor = snapshot.get("editor")
+    if editor:
+        set_custom_editor(ase_file, editor)
+    restored = 0
+    for prop in snapshot["properties"]:
+        node = resolve_property_node(ase_file.graph, property_name=prop["name"])
+        for raw in prop["attributes"]:
+            set_property_metadata_attribute(ase_file.graph, node.node_id, raw)
+            restored += 1
+    sync_compiled_property_metadata(ase_file)
+    return ase_file, restored

asecli/cli/skill_command.py

@@ -0,0 +1,121 @@
+"""Install the packaged ASECLI Agent Skill into a Codex skill directory."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import shutil
+import uuid
+from pathlib import Path
+
+from .commands import CliError
+
+SKILL_NAME = "asecli"
+
+
+def _source_root() -> Path:
+    """Return the skill shipped in the wheel, with a source-tree fallback."""
+    packaged = Path(__file__).resolve().parents[1] / "skills" / SKILL_NAME
+    if (packaged / "SKILL.md").is_file():
+        return packaged
+    source_tree = Path(__file__).resolve().parents[3] / "skills" / SKILL_NAME
+    if (source_tree / "SKILL.md").is_file():
+        return source_tree
+    raise RuntimeError("packaged ASECLI Skill is missing")
+
+
+def _skill_root(raw_root: str | None) -> Path:
+    if raw_root:
+        return Path(raw_root).expanduser()
+    codex_home = os.environ.get("CODEX_HOME")
+    return Path(codex_home).expanduser() / "skills" if codex_home else Path.home() / ".codex" / "skills"
+
+
+def _regular_files(root: Path) -> list[Path]:
+    if root.is_symlink() or not root.is_dir():
+        raise ValueError(f"skill directory is not a regular directory: {root}")
+    files = sorted(path for path in root.rglob("*") if path.is_file())
+    if not files or not (root / "SKILL.md").is_file():
+        raise ValueError(f"skill directory is incomplete: {root}")
+    if any(path.is_symlink() for path in files):
+        raise ValueError(f"skill directory contains a symbolic link: {root}")
+    return files
+
+
+def _tree_digest(root: Path) -> str:
+    digest = hashlib.sha256()
+    for path in _regular_files(root):
+        relative = path.relative_to(root).as_posix().encode("utf-8")
+        digest.update(len(relative).to_bytes(4, "big"))
+        digest.update(relative)
+        content = path.read_bytes()
+        digest.update(len(content).to_bytes(8, "big"))
+        digest.update(content)
+    return digest.hexdigest()
+
+
+def _ensure_regular_parent(root: Path) -> None:
+    root.mkdir(parents=True, exist_ok=True)
+    current = root
+    while current != current.parent:
+        if current.is_symlink():
+            raise ValueError(f"skill root contains a symbolic link: {current}")
+        current = current.parent
+
+
+def install_skill(skill_root: str | None = None) -> dict:
+    """Install the versioned skill once; refuse to replace unrelated content."""
+    source = _source_root()
+    source_digest = _tree_digest(source)
+    root = _skill_root(skill_root)
+    _ensure_regular_parent(root)
+    target = root / SKILL_NAME
+    if target.exists() or target.is_symlink():
+        try:
+            installed_digest = _tree_digest(target)
+        except ValueError as exc:
+            raise FileExistsError(f"existing Skill is unsafe or incomplete: {target}") from exc
+        if installed_digest == source_digest:
+            return {
+                "installed": False,
+                "status": "already_installed",
+                "skill": SKILL_NAME,
+                "path": str(target),
+                "digest": source_digest,
+            }
+        raise FileExistsError(
+            f"existing Skill differs from ASECLI {SKILL_NAME!r}: {target}; "
+            "refusing to overwrite it"
+        )
+
+    staging = root / f".{SKILL_NAME}.staging-{uuid.uuid4().hex}"
+    try:
+        staging.mkdir()
+        for source_path in _regular_files(source):
+            relative = source_path.relative_to(source)
+            destination = staging / relative
+            destination.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copyfile(source_path, destination)
+        if _tree_digest(staging) != source_digest:
+            raise RuntimeError("copied Skill digest does not match packaged source")
+        os.replace(staging, target)
+    except Exception:
+        if staging.exists() and not staging.is_symlink():
+            shutil.rmtree(staging)
+        raise
+    return {
+        "installed": True,
+        "status": "installed",
+        "skill": SKILL_NAME,
+        "path": str(target),
+        "digest": source_digest,
+    }
+
+
+def cmd_install_skill(args) -> dict:
+    try:
+        return install_skill(args.skill_root)
+    except FileExistsError as exc:
+        raise CliError("SKILL_INSTALL_CONFLICT", str(exc)) from exc
+    except (OSError, RuntimeError, ValueError) as exc:
+        raise CliError("SKILL_INSTALL_ERROR", str(exc)) from exc

asecli/cli/usage_command.py

@@ -0,0 +1,42 @@
+"""CLI composition for liveness audit and externally safe node removal."""
+
+from __future__ import annotations
+
+from ..checks import external_references_for_node, usage_audit
+from ..core import remove_node
+from .commands import CliError, _load, _save
+
+
+def cmd_remove_node(args) -> dict:
+    f = _load(args.file)
+    target = f.graph.node_by_id(args.node)
+    if target is None:
+        raise CliError("NOT_FOUND", f"node {args.node} not found")
+    if not args.force_external:
+        try:
+            references = external_references_for_node(args.file, target)
+        except ValueError as exc:
+            raise CliError("USAGE_ERROR", str(exc))
+        if references:
+            raise CliError(
+                "EXTERNAL_REFERENCE",
+                f"node {args.node} property {target.raw_fields[7]} is referenced outside the ASE graph",
+                {"node_id": args.node, "property_name": target.raw_fields[7], "references": references},
+            )
+    try:
+        wires = remove_node(f.graph, args.node)
+    except KeyError as exc:
+        raise CliError("NOT_FOUND", str(exc))
+    except ValueError as exc:
+        raise CliError("VALIDATION_ERROR", str(exc))
+    saved = _save(f, args.file, args.write)
+    return {"removed_node": args.node, "removed_wires": wires, **saved}
+
+
+def cmd_graph_audit(args) -> dict:
+    f = _load(args.file)
+    try:
+        audit = usage_audit(args.file, f.graph)
+    except ValueError as exc:
+        raise CliError("USAGE_ERROR", str(exc))
+    return {"file": args.file, **audit}

asecli/core/__init__.py

@@ -0,0 +1,84 @@
+from .graph_ops import connect, disconnect, next_free_node_id, node_from_schema, remove_node, set_node_field
+from .custom_gui import (
+    ASECLI_GUI_EDITOR,
+    MANAGED_PROPERTY_METADATA_ATTRIBUTE_TYPES,
+    MZGUI_EDITOR,
+    CUSTOM_EDITOR_SUGGESTIONS,
+    PROPERTY_METADATA_ATTRIBUTE_TYPES,
+    SUPPORTED_GUI_EDITORS,
+    compiled_custom_editor,
+    decode_custom_unicode,
+    decode_foldout_title,
+    encode_custom_unicode,
+    encode_foldout_title,
+    graph_custom_editor,
+    inspect_custom_gui,
+    is_material_property_node,
+    main_master_node,
+    parse_property_metadata_attribute,
+    read_property_metadata_tail,
+    remove_property_metadata_attribute,
+    semantic_attribute,
+    set_custom_editor,
+    set_property_metadata_attribute,
+)
+from .property_presentation import (
+    contains_han,
+    require_managed_property_presentation,
+    require_property_presentation,
+    set_property_display_name,
+)
+from .compiled_metadata import sync_compiled_property_metadata
+from .commentary import (
+    COMMENTARY_TYPE,
+    create_comment_group,
+    inspect_comment_groups,
+    parse_commentary_node,
+)
+from .comment_bounds import comment_containment_issues, refit_comment_groups
+from .layout import layout_positions, tidy
+from .meticulous_layout import MeticulousLayoutPlan, apply_meticulous_layout, meticulous_layout_positions
+from .layout_audit import REPORT_SCHEMA, audit_meticulous_layout
+from .comment_layout import refit_comments_for_layout
+from .comment_purpose import govern_comment_purposes
+from .local_vars import (
+    GET_LOCAL_VAR_TYPE,
+    REGISTER_LOCAL_VAR_TYPE,
+    local_var_edges,
+    parse_get_local_var,
+    parse_register_local_var,
+)
+from .wire_router import WIRE_NODE_TYPE, logical_wire_manifest
+from .material_gui_spec import apply_material_gui_spec, material_property_nodes, resolve_property_node
+from .material_gui_condition import (
+    ENABLE_IF_ATTRIBUTE,
+    ENABLE_IF_OPERATORS,
+    enable_if_attribute,
+    parse_enable_if_arguments,
+    validate_enable_if,
+)
+from .model import AseFile, AseGraph, NodeLine, WireLine, _parse_node_line, parse_graph_text, parse_node_line
+
+__all__ = [
+    "AseFile", "AseGraph", "NodeLine", "WireLine", "parse_graph_text", "parse_node_line",
+    "connect", "disconnect", "next_free_node_id", "node_from_schema", "remove_node", "set_node_field",
+    "layout_positions", "tidy", "MeticulousLayoutPlan", "apply_meticulous_layout",
+    "meticulous_layout_positions", "REPORT_SCHEMA", "audit_meticulous_layout",
+    "govern_comment_purposes", "refit_comments_for_layout",
+    "ASECLI_GUI_EDITOR", "MZGUI_EDITOR", "CUSTOM_EDITOR_SUGGESTIONS", "PROPERTY_METADATA_ATTRIBUTE_TYPES", "MANAGED_PROPERTY_METADATA_ATTRIBUTE_TYPES",
+    "SUPPORTED_GUI_EDITORS",
+    "compiled_custom_editor", "decode_custom_unicode", "decode_foldout_title",
+    "encode_custom_unicode", "encode_foldout_title", "graph_custom_editor",
+    "inspect_custom_gui", "is_material_property_node", "main_master_node", "parse_property_metadata_attribute", "read_property_metadata_tail",
+    "contains_han", "require_managed_property_presentation", "require_property_presentation", "set_property_display_name",
+    "remove_property_metadata_attribute", "semantic_attribute", "set_custom_editor", "set_property_metadata_attribute",
+    "sync_compiled_property_metadata",
+    "apply_material_gui_spec", "material_property_nodes", "resolve_property_node",
+    "ENABLE_IF_ATTRIBUTE", "ENABLE_IF_OPERATORS", "enable_if_attribute",
+    "parse_enable_if_arguments", "validate_enable_if",
+    "COMMENTARY_TYPE", "comment_containment_issues", "create_comment_group",
+    "inspect_comment_groups", "parse_commentary_node", "refit_comment_groups",
+    "GET_LOCAL_VAR_TYPE", "REGISTER_LOCAL_VAR_TYPE", "local_var_edges",
+    "parse_get_local_var", "parse_register_local_var",
+    "WIRE_NODE_TYPE", "logical_wire_manifest",
+]

asecli/core/comment_bounds.py

@@ -0,0 +1,166 @@
+"""Editor-accurate containment checks and resizing for ASE Comment frames."""
+
+from __future__ import annotations
+
+from .commentary import (
+    NodeBounds,
+    _node_bounds,
+    _number,
+    _rect_overlap,
+    inspect_comment_groups,
+    parse_commentary_node,
+)
+from .model import AseGraph
+
+
+def comment_containment_issues(
+    graph: AseGraph,
+    node_bounds: dict[str, NodeBounds],
+    *,
+    tolerance: float = 0.01,
+) -> list[dict]:
+    """Report members outside frames and unrelated Comment frames that overlap."""
+    issues: list[dict] = []
+    groups = inspect_comment_groups(graph)
+    for group in groups:
+        frame = (
+            group["position"]["x"], group["position"]["y"],
+            group["position"]["x"] + group["width"],
+            group["position"]["y"] + group["height"],
+        )
+        for member_id in group["members"]:
+            member = graph.node_by_id(member_id)
+            if member is None:
+                continue
+            bounds = _node_bounds(member, node_bounds)
+            overflow = {
+                "left": max(0.0, frame[0] - bounds[0]),
+                "top": max(0.0, frame[1] - bounds[1]),
+                "right": max(0.0, bounds[2] - frame[2]),
+                "bottom": max(0.0, bounds[3] - frame[3]),
+            }
+            overflow = {key: round(value, 3) for key, value in overflow.items() if value > tolerance}
+            if overflow:
+                issues.append({
+                    "code": "COMMENT_MEMBER_OUTSIDE_FRAME",
+                    "severity": "warning",
+                    "comment_id": group["node_id"],
+                    "comment_title": group["title"],
+                    "member_id": member_id,
+                    "overflow": overflow,
+                    "message": f"comment {group['node_id']} does not fully contain member {member_id}",
+                })
+    group_ids = {group["node_id"] for group in groups}
+    children = {
+        group["node_id"]: [member_id for member_id in group["members"] if member_id in group_ids]
+        for group in groups
+    }
+
+    def is_ancestor(ancestor_id: str, descendant_id: str) -> bool:
+        stack = list(children[ancestor_id])
+        visited: set[str] = set()
+        while stack:
+            current = stack.pop()
+            if current == descendant_id:
+                return True
+            if current in visited:
+                raise ValueError(f"comment membership contains a cycle at node {current}")
+            visited.add(current)
+            stack.extend(children[current])
+        return False
+
+    frames = {
+        group["node_id"]: (
+            group["position"]["x"],
+            group["position"]["y"],
+            group["position"]["x"] + group["width"],
+            group["position"]["y"] + group["height"],
+        )
+        for group in groups
+    }
+    for index, left in enumerate(groups):
+        for right in groups[index + 1:]:
+            left_id, right_id = left["node_id"], right["node_id"]
+            if is_ancestor(left_id, right_id) or is_ancestor(right_id, left_id):
+                continue
+            overlap = _rect_overlap(frames[left_id], frames[right_id], tolerance=tolerance)
+            if overlap is not None:
+                issues.append({
+                    "code": "COMMENT_GROUP_OVERLAP",
+                    "severity": "warning",
+                    "comment_ids": [left_id, right_id],
+                    "comment_titles": [left["title"], right["title"]],
+                    "overlap": overlap,
+                    "message": f"unrelated comment groups {left_id} and {right_id} overlap",
+                })
+    return issues
+
+
+def refit_comment_groups(
+    graph: AseGraph,
+    node_bounds: dict[str, NodeBounds],
+    *,
+    padding: float = 50.0,
+    group_ids: list[str] | None = None,
+) -> list[dict]:
+    """Resize frames around live bounds without moving members."""
+    if not 0 <= padding <= 1000:
+        raise ValueError("padding must be between 0 and 1000")
+    groups = {group["node_id"]: group for group in inspect_comment_groups(graph)}
+    selected = set(groups) if group_ids is None else {str(value) for value in group_ids}
+    missing = sorted(selected - set(groups), key=_node_id_sort_key)
+    if missing:
+        raise KeyError(f"comment node(s) not found: {', '.join(missing)}")
+    changes: list[dict] = []
+    fitted: set[str] = set()
+    visiting: set[str] = set()
+
+    def fit(group_id: str) -> None:
+        if group_id in fitted:
+            return
+        if group_id in visiting:
+            raise ValueError(f"comment membership contains a cycle at node {group_id}")
+        visiting.add(group_id)
+        group = groups[group_id]
+        bounds: list[NodeBounds] = []
+        for member_id in group["members"]:
+            member = graph.node_by_id(member_id)
+            if member is None:
+                raise KeyError(f"node {member_id} not found")
+            if member_id in groups and member_id in selected:
+                fit(member_id)
+            bounds.append(_node_bounds(member, node_bounds))
+        if not bounds:
+            raise ValueError(f"comment {group_id} has no members to fit")
+        min_x, min_y = min(item[0] for item in bounds), min(item[1] for item in bounds)
+        max_x, max_y = max(item[2] for item in bounds), max(item[3] for item in bounds)
+        after = {
+            "position": {"x": min_x - padding, "y": min_y - padding},
+            "width": max(100.0, max_x - min_x + 2 * padding),
+            "height": max(100.0, max_y - min_y + 2 * padding),
+        }
+        before = {
+            "position": dict(group["position"]),
+            "width": group["width"], "height": group["height"],
+        }
+        node = graph.node_by_id(group_id)
+        assert node is not None
+        node.raw_fields[3] = f"{_number(after['position']['x'])},{_number(after['position']['y'])}"
+        node.raw_fields[6], node.raw_fields[7] = _number(after["width"]), _number(after["height"])
+        graph.replace_node(node)
+        groups[group_id] = parse_commentary_node(node)
+        if before != after:
+            changes.append({
+                "comment_id": group_id, "title": group["title"],
+                "before": before, "after": after,
+            })
+        visiting.remove(group_id)
+        fitted.add(group_id)
+
+    for group_id in sorted(selected, key=_node_id_sort_key):
+        fit(group_id)
+    return changes
+
+
+def _node_id_sort_key(value: str) -> tuple[int, int | str]:
+    return (0, int(value)) if value.lstrip("-").isdigit() else (1, value)

asecli/core/comment_layout.py

@@ -0,0 +1,167 @@
+"""Recursive Comment fitting and quality metrics for meticulous layout."""
+
+from __future__ import annotations
+
+from typing import Mapping, Protocol
+
+from .commentary import _number, inspect_comment_groups, parse_commentary_node
+from .model import AseGraph
+
+SIDE_PADDING = 30.0
+TOP_PADDING = 48.0
+BOTTOM_PADDING = 30.0
+MODULE_GAP = 96.0
+
+
+class Geometry(Protocol):
+    width: float
+    height: float
+
+
+def refit_comments_for_layout(
+    graph: AseGraph,
+    geometry: Mapping[str, Geometry],
+    positions: Mapping[str, tuple[float, float]],
+) -> list[dict]:
+    """Fit Comments, then move unrelated groups apart as intact composites."""
+    if not isinstance(positions, dict):
+        raise ValueError("layout positions must be mutable while fitting Comment groups")
+    original = {
+        group["node_id"]: {
+            "position": dict(group["position"]), "width": group["width"], "height": group["height"],
+        }
+        for group in inspect_comment_groups(graph)
+    }
+
+    def fit_all() -> dict[str, dict]:
+        groups = {group["node_id"]: group for group in inspect_comment_groups(graph)}
+        fitted: set[str] = set()
+        visiting: set[str] = set()
+
+        def bounds(member_id: str):
+            if member_id in groups:
+                fit(member_id)
+                group = groups[member_id]
+                x, y = group["position"].values()
+                return x, y, x + group["width"], y + group["height"]
+            if member_id not in geometry or member_id not in positions:
+                raise ValueError(f"layout geometry missing Comment member {member_id}")
+            x, y = positions[member_id]
+            return x, y, x + geometry[member_id].width, y + geometry[member_id].height
+
+        def fit(group_id: str) -> None:
+            if group_id in fitted:
+                return
+            if group_id in visiting:
+                raise ValueError(f"comment membership contains a cycle at node {group_id}")
+            visiting.add(group_id)
+            group = groups[group_id]
+            if not group["members"]:
+                raise ValueError(f"comment {group_id} has no members to fit")
+            member_bounds = [bounds(member_id) for member_id in group["members"]]
+            left = min(rect[0] for rect in member_bounds) - SIDE_PADDING
+            top = min(rect[1] for rect in member_bounds) - TOP_PADDING
+            right = max(rect[2] for rect in member_bounds) + SIDE_PADDING
+            bottom = max(rect[3] for rect in member_bounds) + BOTTOM_PADDING
+            node = graph.node_by_id(group_id)
+            if node is None:
+                raise ValueError(f"comment node {group_id} not found")
+            node.raw_fields[3] = f"{_number(left)},{_number(top)}"
+            node.raw_fields[6] = _number(max(100.0, right - left))
+            node.raw_fields[7] = _number(max(100.0, bottom - top))
+            graph.replace_node(node)
+            groups[group_id] = parse_commentary_node(node)
+            visiting.remove(group_id)
+            fitted.add(group_id)
+
+        for group_id in sorted(groups, key=_id_key):
+            fit(group_id)
+        return groups
+
+    groups = fit_all()
+    max_moves = max(1, len(groups) * len(groups))
+    for _ in range(max_moves):
+        conflict = _first_group_channel_conflict(groups)
+        if conflict is None:
+            break
+        upper_id, lower_id, dy = conflict
+        del upper_id
+        _move_comment_members(graph, groups, lower_id, dy, positions)
+        groups = fit_all()
+    else:
+        raise ValueError("unable to separate unrelated Comment groups")
+
+    final = {group["node_id"]: group for group in inspect_comment_groups(graph)}
+    changes = []
+    for group_id in sorted(final, key=_id_key):
+        group = final[group_id]
+        after = {
+            "position": dict(group["position"]), "width": group["width"], "height": group["height"],
+        }
+        if original[group_id] != after:
+            changes.append({"comment_id": group_id, "before": original[group_id], "after": after})
+    return changes
+
+
+def _first_group_channel_conflict(groups: dict[str, dict]):
+    parent_of = {
+        member: group["node_id"]
+        for group in groups.values() for member in group["members"] if member in groups
+    }
+
+    def ancestors(group_id: str) -> set[str]:
+        result = set()
+        current = parent_of.get(group_id)
+        while current is not None:
+            if current in result:
+                raise ValueError(f"comment membership contains a cycle at node {current}")
+            result.add(current)
+            current = parent_of.get(current)
+        return result
+
+    ordered = sorted(
+        groups.values(),
+        key=lambda group: (group["position"]["y"], group["position"]["x"], _id_key(group["node_id"])),
+    )
+    for index, upper in enumerate(ordered):
+        upper_id = upper["node_id"]
+        upper_ancestors = ancestors(upper_id)
+        upper_rect = _group_rect(upper)
+        for lower in ordered[index + 1:]:
+            lower_id = lower["node_id"]
+            if lower_id in upper_ancestors or upper_id in ancestors(lower_id):
+                continue
+            lower_rect = _group_rect(lower)
+            x_overlap = not (
+                upper_rect[2] + MODULE_GAP <= lower_rect[0]
+                or lower_rect[2] + MODULE_GAP <= upper_rect[0]
+            )
+            y_clear = upper_rect[3] + MODULE_GAP <= lower_rect[1]
+            if x_overlap and not y_clear:
+                return upper_id, lower_id, upper_rect[3] + MODULE_GAP - lower_rect[1]
+    return None
+
+
+def _move_comment_members(graph, groups, group_id: str, dy: float, positions: dict) -> None:
+    for member_id in groups[group_id]["members"]:
+        if member_id in groups:
+            _move_comment_members(graph, groups, member_id, dy, positions)
+            continue
+        if member_id not in positions:
+            raise ValueError(f"layout positions missing Comment member {member_id}")
+        x, y = positions[member_id]
+        positions[member_id] = (x, round(y + dy, 1))
+        node = graph.node_by_id(member_id)
+        if node is None:
+            raise ValueError(f"comment member {member_id} not found")
+        node.raw_fields[3] = f"{_number(x)},{_number(round(y + dy, 1))}"
+        graph.replace_node(node)
+
+
+def _group_rect(group):
+    x, y = group["position"].values()
+    return x, y, x + group["width"], y + group["height"]
+
+
+def _id_key(value: str) -> tuple[int, int | str]:
+    return (0, int(value)) if value.lstrip("-").isdigit() else (1, value)