@litfamily/lithermes 1.0.7 → 1.0.9

package/assets/lithermes-plugin/skills/lit-diagram-drawer/scripts/diagram_quality_geometry.py

@@ -0,0 +1,200 @@
+"""Small geometry predicates shared by the visual-quality checks."""
+
+from __future__ import annotations
+
+from math import hypot
+
+from diagram_records import Boundary, Marker, Rect, Route, Segment, TextBox
+
+
+def segment_hits_rect(segment: Segment, rect: Rect, pad: float = 0) -> bool:
+    """Check axis-aligned routes exactly and diagonal routes by bounded sampling."""
+    x1, y1, x2, y2 = segment
+    left, right = rect.x - pad, rect.right + pad
+    top, bottom = rect.y - pad, rect.bottom + pad
+    if x1 == x2:
+        return left <= x1 <= right and max(y1, y2) >= top and min(y1, y2) <= bottom
+    if y1 == y2:
+        return top <= y1 <= bottom and max(x1, x2) >= left and min(x1, x2) <= right
+    return any(
+        left <= x1 + (x2 - x1) * step / 24 <= right
+        and top <= y1 + (y2 - y1) * step / 24 <= bottom
+        for step in range(25)
+    )
+
+
+def segment_hits_text(segment: Segment, text: TextBox, pad: float = 1) -> bool:
+    bounds = text.bounds
+    return segment_hits_rect(segment, Rect(bounds.x - pad, bounds.y - pad, bounds.w + 2 * pad, bounds.h + 2 * pad))
+
+
+def text_overlaps_node(text: TextBox, node: Rect, pad: float = 1) -> bool:
+    bounds = text.bounds
+    return bounds.x < node.right + pad and bounds.right > node.x - pad and bounds.y < node.bottom + pad and bounds.bottom > node.y - pad
+
+
+def rectangle_gap(first: Rect, second: Rect) -> float:
+    dx = max(0.0, first.x - second.right, second.x - first.right)
+    dy = max(0.0, first.y - second.bottom, second.y - first.bottom)
+    return hypot(dx, dy)
+
+
+def point_segment_distance(point: tuple[float, float], segment: Segment) -> float:
+    x1, y1, x2, y2 = segment
+    dx, dy = x2 - x1, y2 - y1
+    length = dx * dx + dy * dy
+    weight = max(0.0, min(1.0, ((point[0] - x1) * dx + (point[1] - y1) * dy) / length)) if length else 0.0
+    return hypot(point[0] - (x1 + weight * dx), point[1] - (y1 + weight * dy))
+
+
+def route_distance(point: tuple[float, float], route: Route) -> float:
+    return min((point_segment_distance(point, segment) for segment in route.segments), default=float("inf"))
+
+
+def route_length(route: Route) -> float:
+    return sum(hypot(segment[2] - segment[0], segment[3] - segment[1]) for segment in route.segments)
+
+
+def route_bends(route: Route) -> int:
+    directions = []
+    for x1, y1, x2, y2 in route.segments:
+        length = hypot(x2 - x1, y2 - y1)
+        if length:
+            directions.append(((x2 - x1) / length, (y2 - y1) / length))
+    return sum(
+        directions[index - 1][0] * directions[index][0] + directions[index - 1][1] * directions[index][1] < 2**-0.5
+        for index in range(1, len(directions))
+    )
+
+
+def route_manhattan_distance(route: Route) -> float | None:
+    if not route.segments:
+        return None
+    first, last = route.segments[0], route.segments[-1]
+    distance = abs(first[0] - last[2]) + abs(first[1] - last[3])
+    return distance or None
+
+
+def route_crosses_boundary(route: Route, boundary: Boundary) -> bool:
+    points = [
+        point
+        for x1, y1, x2, y2 in route.segments
+        for point in ((x1, y1), (x2, y2), ((x1 + x2) / 2, (y1 + y2) / 2))
+    ]
+    inside = any(boundary.rect.x < x < boundary.rect.right and boundary.rect.y < y < boundary.rect.bottom for x, y in points)
+    outside = any(x < boundary.rect.x or x > boundary.rect.right or y < boundary.rect.y or y > boundary.rect.bottom for x, y in points)
+    return inside and outside
+
+
+def segment_along_boundary(segment: Segment, boundary: Boundary) -> bool:
+    x1, y1, x2, y2 = segment
+    rect = boundary.rect
+    if abs(y1 - y2) <= 1:
+        overlap = min(max(x1, x2), rect.right) - max(min(x1, x2), rect.x)
+        return overlap > 12 and (abs(y1 - rect.y) <= 4 or abs(y1 - rect.bottom) <= 4)
+    if abs(x1 - x2) <= 1:
+        overlap = min(max(y1, y2), rect.bottom) - max(min(y1, y2), rect.y)
+        return overlap > 12 and (abs(x1 - rect.x) <= 4 or abs(x1 - rect.right) <= 4)
+    return False
+
+
+def _orientation(first: tuple[float, float], second: tuple[float, float], third: tuple[float, float]) -> float:
+    return (second[0] - first[0]) * (third[1] - first[1]) - (second[1] - first[1]) * (third[0] - first[0])
+
+
+def segment_intersection(first: Segment, second: Segment) -> tuple[float, float] | None:
+    rx, ry, sx, sy = first[2] - first[0], first[3] - first[1], second[2] - second[0], second[3] - second[1]
+    denominator = rx * sy - ry * sx
+    if abs(denominator) < 1e-8:
+        return None
+    qx, qy = second[0] - first[0], second[1] - first[1]
+    t, u = (qx * sy - qy * sx) / denominator, (qx * ry - qy * rx) / denominator
+    return (first[0] + t * rx, first[1] + t * ry) if -1e-8 <= t <= 1 + 1e-8 and -1e-8 <= u <= 1 + 1e-8 else None
+
+
+def route_crossings(first: Route, second: Route) -> tuple[tuple[float, float], ...]:
+    first_endpoints = ((first.from_id, first.segments[0][:2]), (first.to_id, first.segments[-1][2:])) if first.segments else ()
+    second_endpoints = ((second.from_id, second.segments[0][:2]), (second.to_id, second.segments[-1][2:])) if second.segments else ()
+    points: list[tuple[float, float]] = []
+    for left in first.segments:
+        for right in second.segments:
+            point = segment_intersection(left, right)
+            if point is None:
+                continue
+            shared = any(
+                left_id == right_id and hypot(left_point[0] - right_point[0], left_point[1] - right_point[1]) <= 0.5
+                and hypot(left_point[0] - point[0], left_point[1] - point[1]) <= 0.5
+                for left_id, left_point in first_endpoints for right_id, right_point in second_endpoints
+            )
+            if not shared and not any(hypot(old[0] - point[0], old[1] - point[1]) <= 0.5 for old in points):
+                points.append(point)
+    return tuple(points)
+
+
+def routes_overlap_collinearly(first: Route, second: Route) -> bool:
+    for ax1, ay1, ax2, ay2 in first.segments:
+        for bx1, by1, bx2, by2 in second.segments:
+            if abs(ay1 - ay2) <= 0.5 and abs(by1 - by2) <= 0.5 and abs(ay1 - by1) < 12:
+                if min(max(ax1, ax2), max(bx1, bx2)) - max(min(ax1, ax2), min(bx1, bx2)) >= 12:
+                    return True
+            if abs(ax1 - ax2) <= 0.5 and abs(bx1 - bx2) <= 0.5 and abs(ax1 - bx1) < 12:
+                if min(max(ay1, ay2), max(by1, by2)) - max(min(ay1, ay2), min(by1, by2)) >= 12:
+                    return True
+    return False
+
+
+def marker_scale(marker: Marker, route: Route) -> float:
+    return 1.0 if marker.units == "userSpaceOnUse" else route.stroke_width
+
+
+def marker_length(marker: Marker) -> float:
+    return max((point[0] for point in marker.points), default=0) - min((point[0] for point in marker.points), default=0)
+
+
+def marker_tip(route: Route, marker: Marker, edge: str) -> tuple[float, float] | None:
+    if not route.segments:
+        return None
+    segment = route.segments[-1] if edge == "end" else route.segments[0]
+    x1, y1, x2, y2 = segment
+    dx, dy = x2 - x1, y2 - y1
+    length = hypot(dx, dy) or 1
+    direction = 1 if edge == "end" else -1
+    forward = max((direction * (point[0] - marker.ref_x) for point in marker.points), default=0) * marker_scale(marker, route)
+    anchor = (x2, y2) if edge == "end" else (x1, y1)
+    return anchor[0] + direction * dx / length * forward, anchor[1] + direction * dy / length * forward
+
+
+def distance_to_rect_boundary(point: tuple[float, float], rect: Rect) -> float:
+    x, y = point
+    candidates = []
+    if rect.y - 2 <= y <= rect.bottom + 2:
+        candidates.extend((abs(x - rect.x), abs(x - rect.right)))
+    if rect.x - 2 <= x <= rect.right + 2:
+        candidates.extend((abs(y - rect.y), abs(y - rect.bottom)))
+    if candidates:
+        return min(candidates)
+    return hypot(max(rect.x - x, 0, x - rect.right), max(rect.y - y, 0, y - rect.bottom))
+
+
+def marker_overlaps_rect(route: Route, rect: Rect, marker: Marker) -> bool:
+    """Transform marker outline points onto the final routed segment."""
+    if not route.segments:
+        return False
+    x1, y1, x2, y2 = route.segments[-1]
+    length = hypot(x2 - x1, y2 - y1) or 1
+    ux, uy = (x2 - x1) / length, (y2 - y1) / length
+    nx, ny = -uy, ux
+    scale = marker_scale(marker, route)
+    points = tuple(
+        (
+            x2 + ux * (x - marker.ref_x) * scale + nx * (y - marker.ref_y) * scale,
+            y2 + uy * (x - marker.ref_x) * scale + ny * (y - marker.ref_y) * scale,
+        )
+        for x, y in marker.points
+    )
+    if any(rect.x + 1 < x < rect.right - 1 and rect.y + 1 < y < rect.bottom - 1 for x, y in points):
+        return True
+    edges = tuple((points[index][0], points[index][1], points[index + 1][0], points[index + 1][1]) for index in range(len(points) - 1))
+    if marker.closed and len(points) > 2:
+        edges += ((points[-1][0], points[-1][1], points[0][0], points[0][1]),)
+    return any(segment_hits_rect(edge, rect, -1) for edge in edges)

package/assets/lithermes-plugin/skills/lit-diagram-drawer/scripts/diagram_records.py

@@ -0,0 +1,205 @@
+"""Immutable geometry records and SVG lexical helpers."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from html import unescape
+import re
+from types import MappingProxyType
+from typing import Mapping
+
+_ATTR_RE = re.compile(r"([\w:-]+)\s*=\s*(?:\"([^\"]*)\"|'([^']*)')")
+_PATH_TOKEN_RE = re.compile(r"[a-zA-Z]|[-+]?(?:\d*\.\d+|\d+\.?\d*)(?:e[-+]?\d+)?", re.IGNORECASE)
+
+@dataclass(frozen=True, slots=True)
+class Rect:
+    x: float
+    y: float
+    w: float
+    h: float
+
+    @property
+    def right(self) -> float:
+        return self.x + self.w
+
+    @property
+    def bottom(self) -> float:
+        return self.y + self.h
+
+
+@dataclass(frozen=True, slots=True)
+class Shape:
+    kind: str
+    rect: Rect
+    fill: str
+    attributes: Mapping[str, str]
+
+
+@dataclass(frozen=True, slots=True)
+class TextBox:
+    label: str
+    bounds: Rect
+    anchor: tuple[float, float]
+    font_size: float
+    fill: str
+    role: str
+    edge_for: str
+    boundary_for: str
+
+
+Segment = tuple[float, float, float, float]
+
+
+@dataclass(frozen=True, slots=True)
+class Route:
+    from_id: str
+    to_id: str
+    label: str
+    segments: tuple[Segment, ...]
+    marker_start: str
+    marker_end: str
+    stroke_width: float
+
+
+@dataclass(frozen=True, slots=True)
+class Boundary:
+    name: str
+    labels: tuple[str, ...]
+    rect: Rect
+    stroke_width: float
+
+
+@dataclass(frozen=True, slots=True)
+class Marker:
+    name: str
+    ref_x: float
+    ref_y: float
+    units: str
+    points: tuple[tuple[float, float], ...]
+    closed: bool
+
+
+@dataclass(frozen=True, slots=True)
+class ParsedSvg:
+    source: str
+    svg: str
+    attributes: Mapping[str, str]
+    view_box: Rect | None
+    shapes: tuple[Shape, ...]
+    texts: tuple[TextBox, ...]
+    routes: tuple[Route, ...]
+    line_segments: tuple[Segment, ...]
+    boundaries: tuple[Boundary, ...]
+    markers: Mapping[str, Marker]
+
+
+def attributes(markup: str) -> Mapping[str, str]:
+    """Read quoted SVG attributes without evaluating or normalizing source markup."""
+    return MappingProxyType({
+        match.group(1): unescape(match.group(2) if match.group(2) is not None else match.group(3) or "")
+        for match in _ATTR_RE.finditer(markup)
+    })
+
+
+def _number(value: str | None, default: float = 0.0) -> float:
+    if value is None:
+        return default
+    try:
+        return float(value)
+    except ValueError:
+        return default
+
+
+def _clean(value: str) -> str:
+    return re.sub(r"\s+", " ", unescape(re.sub(r"<[^>]*>", " ", value))).strip()
+
+
+def glyph_width(text: str, font_size: float) -> float:
+    units = 0.0
+    for character in text:
+        if character.isspace():
+            units += 0.28
+        elif "\u1100" <= character <= "\ud7af":
+            units += 0.98
+        elif character in "ilI.,:;!|":
+            units += 0.32
+        elif character in "MW@#%":
+            units += 0.82
+        else:
+            units += 0.56
+    return units * font_size
+
+
+def _path_segments(path_data: str, *, curve_steps: int = 12) -> tuple[Segment, ...]:
+    tokens = _PATH_TOKEN_RE.findall(path_data)
+    segments: list[Segment] = []
+    index = 0
+    command = ""
+    x = y = start_x = start_y = 0.0
+
+    def is_command(token: str) -> bool:
+        return len(token) == 1 and token.isalpha()
+
+    def point(relative: bool) -> tuple[float, float]:
+        nonlocal index
+        px = float(tokens[index])
+        py = float(tokens[index + 1])
+        index += 2
+        return (x + px, y + py) if relative else (px, py)
+
+    while index < len(tokens):
+        if is_command(tokens[index]):
+            command = tokens[index]
+            index += 1
+        if not command:
+            break
+        relative = command.islower()
+        verb = command.upper()
+        if verb == "Z":
+            if (x, y) != (start_x, start_y):
+                segments.append((x, y, start_x, start_y))
+            x, y, command = start_x, start_y, ""
+        elif verb in {"M", "L"}:
+            if index + 1 >= len(tokens) or is_command(tokens[index]):
+                command = ""
+                continue
+            nx, ny = point(relative)
+            if verb == "L":
+                segments.append((x, y, nx, ny))
+            x, y = nx, ny
+            if verb == "M":
+                start_x, start_y = x, y
+                command = "l" if relative else "L"
+        elif verb in {"H", "V"}:
+            if index >= len(tokens) or is_command(tokens[index]):
+                command = ""
+                continue
+            value = float(tokens[index])
+            index += 1
+            nx, ny = (x + value if relative else value, y) if verb == "H" else (x, y + value if relative else value)
+            segments.append((x, y, nx, ny))
+            x, y = nx, ny
+        elif verb == "C":
+            if index + 5 >= len(tokens) or is_command(tokens[index]):
+                command = ""
+                continue
+            c1 = point(relative)
+            c2 = point(relative)
+            end = point(relative)
+            origin = (x, y)
+            previous = origin
+            for step in range(1, curve_steps + 1):
+                t = step / curve_steps
+                u = 1 - t
+                current = (
+                    u**3 * origin[0] + 3 * u**2 * t * c1[0] + 3 * u * t**2 * c2[0] + t**3 * end[0],
+                    u**3 * origin[1] + 3 * u**2 * t * c1[1] + 3 * u * t**2 * c2[1] + t**3 * end[1],
+                )
+                segments.append((previous[0], previous[1], current[0], current[1]))
+                previous = current
+            x, y = end
+        else:
+            while index < len(tokens) and not is_command(tokens[index]):
+                index += 1
+            command = ""
+    return tuple(segments)

package/assets/lithermes-plugin/skills/lit-diagram-drawer/scripts/diagram_sequence.py

@@ -0,0 +1,55 @@
+"""Sequence-diagram lifeline, endpoint, and message-order checks."""
+
+from __future__ import annotations
+
+import re
+
+from diagram_geometry import ParsedSvg
+from diagram_records import Shape
+from diagram_records import attributes
+
+
+def sequence_issues(source: str, parsed: ParsedSvg, nodes: tuple[Shape, ...]) -> list[str]:
+    """Check participants and ordered messages when the source declares a sequence."""
+    declared = re.search(r"\bdata-type\s*=\s*['\"]sequence(?:-oauth)?['\"]", source, re.IGNORECASE)
+    identified = re.search(r"\bid\s*=\s*['\"]diagram-sequence(?:-oauth)?-[^'\"]+['\"]", parsed.svg, re.IGNORECASE)
+    if not declared and not identified:
+        return []
+    lifelines: dict[str, tuple[float, float, float]] = {}
+    for match in re.finditer(r"<line\b([^>]*)/?>", parsed.svg, re.IGNORECASE):
+        attrs = attributes(match.group(1))
+        name = attrs.get("data-lifeline-for", "")
+        if name and attrs.get("stroke-dasharray") and attrs.get("x1") == attrs.get("x2"):
+            try:
+                top, bottom = float(attrs.get("y1", "nan")), float(attrs.get("y2", "nan"))
+            except ValueError:
+                continue
+            if bottom > top:
+                lifelines[name] = (float(attrs["x1"]), top, bottom)
+    messages = [
+        (route, route.segments[0][:2], route.segments[-1][2:], (route.segments[0][1] + route.segments[-1][3]) / 2)
+        for route in parsed.routes if route.segments
+    ]
+    issues: list[str] = []
+    last_message_y = max((message[3] for message in messages), default=0)
+    for node in nodes:
+        name = node.attributes["data-node-id"]
+        line = lifelines.get(name)
+        if line is None:
+            issues.append(f"SEQUENCE_LIFELINE_MISSING {name}")
+            continue
+        if abs(line[0] - (node.rect.x + node.rect.w / 2)) > 1 or abs(line[1] - node.rect.bottom) > 1:
+            issues.append(f"SEQUENCE_LIFELINE_ALIGNMENT {name}")
+        if line[2] + 1 < last_message_y:
+            issues.append(f"SEQUENCE_LIFELINE_SHORT {name} ends before last message")
+    previous_y = float("-inf")
+    for route, start, end, message_y in messages:
+        from_line, to_line = lifelines.get(route.from_id), lifelines.get(route.to_id)
+        if from_line is None or to_line is None:
+            continue
+        if abs(start[0] - from_line[0]) > 1 or abs(end[0] - to_line[0]) > 1:
+            issues.append(f"SEQUENCE_MESSAGE_OFF_LIFELINE {route.from_id}->{route.to_id}")
+        if message_y <= previous_y:
+            issues.append(f"SEQUENCE_MESSAGE_ORDER {route.from_id}->{route.to_id} is not top-to-bottom")
+        previous_y = message_y
+    return issues

package/assets/lithermes-plugin/skills/lit-diagram-drawer/scripts/doctor.mjs

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { agentBrowserSupported } from './browser-version.mjs';
+
+const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
+const report=[];
+function check(name,ok,detail){report.push({name,status:ok?'pass':'fail',detail});}
+const version=spawnSync('agent-browser',['--version'],{encoding:'utf8'});
+check('agent-browser >=0.38.1',version.status===0&&agentBrowserSupported(version.stdout),(version.stdout||version.stderr||'not found').trim());
+const browser=spawnSync('agent-browser',['doctor','--json'],{encoding:'utf8'});
+let doctor=null;try{doctor=JSON.parse(browser.stdout);}catch{}
+const chrome=doctor?.checks?.find((x)=>x.id==='chrome.installed')?.message||'';
+check('Chrome for Testing 154',!!doctor?.success&&chrome.includes('154.'),chrome||'not found');
+const font=path.join(root,'assets/fonts/PretendardVariable.woff2');
+const license=path.join(root,'assets/fonts/OFL.txt');
+for(const file of [font,license]) check(path.relative(root,file),fs.existsSync(file),fs.existsSync(file)?String(fs.statSync(file).size)+' bytes':'missing');
+if(fs.existsSync(font)) check('font SHA-256 manifest',(()=>{try{const m=JSON.parse(fs.readFileSync(path.join(root,'assets/fonts/provenance.json'),'utf8'));return m.files?.some((f)=>f.file==='PretendardVariable.woff2'&&f.sha256===crypto.createHash('sha256').update(fs.readFileSync(font)).digest('hex'));}catch{return false;}})(),'matches bundled provenance record');
+const failures=report.filter((x)=>x.status==='fail');
+console.log(JSON.stringify({ok:failures.length===0,checks:report},null,2));
+if(failures.length)process.exitCode=1;