@giamme/forge 0.8.0 → 0.9.0

package/ui/forge_ui/fractal.py

@@ -47,8 +47,7 @@ def supported():
 
 
 def state_root():
-    """forge_fractal.state_root(), except that an empty XDG_STATE_HOME counts as unset (forge
-    resolves '' to its working directory)."""
+    """forge_fractal.state_root(): an empty XDG_STATE_HOME counts as unset."""
     base = os.environ.get('XDG_STATE_HOME') or os.path.join(os.path.expanduser('~'), '.local', 'state')
     return os.path.join(os.path.realpath(os.path.expanduser(base)), 'forge', 'fractal')
 

package/ui/forge_ui/reader.py

@@ -11,7 +11,7 @@ import re
 import stat
 import urllib.parse
 
-from forge_ui import diffs, executions, findings, fractal
+from forge_ui import diffs, executions, findings, fractal, transcripts
 from forge_ui.findings import verdict as _verdict
 
 
@@ -824,9 +824,8 @@ def task_detail(path, task_id, source='plan'):
                 reviews=reviews, truncated=reader.truncated, warnings=reader.warnings)
 
 
-def execution_detail(path, name, source='plan'):
-    """ExecutionDetail of one attempts/<role>-<uuid>/ dir of the run, or None."""
-    reader = _Read(path)
+def _execution(reader, name):
+    """(Execution, owner, owner dir) of the execution `name` of the run, or None."""
     kind = _kind(reader.path)
     if kind is None or not executions.NAME.fullmatch(name or ''):
         return None
@@ -856,8 +855,16 @@ def execution_detail(path, name, source='plan'):
         execs = _final_review(reader, items[index], index == 0, _published(reader))[1]
         owner, owner_dir = dict(kind='final_review', id=parts[0]), items[index][3]
     item = next((candidate for candidate in execs if candidate['id'] == name), None)
-    if item is None:
+    return None if item is None else (item, owner, owner_dir)
+
+
+def execution_detail(path, name, source='plan'):
+    """ExecutionDetail of one attempts/<role>-<uuid>/ dir of the run, or None."""
+    reader = _Read(path)
+    found = _execution(reader, name)
+    if found is None:
         return None
+    item, owner, owner_dir = found
     role, running = item['role'], item['state'] == 'running'
     resolved = executions.resolved_of(reader, f'{item.rel}/{role}.resolved')
     prompt = last = listed = None
@@ -880,6 +887,37 @@ def execution_detail(path, name, source='plan'):
     return result
 
 
+def execution_transcript(path, name, source='plan'):
+    """ExecutionTranscript of a dwarf or qa execution: its agent's conversation, read from its `.log`; None
+    when there is no such execution or it is of another role."""
+    reader = _Read(path)
+    found = _execution(reader, name)
+    if found is None or found[0]['role'] not in ('dwarf', 'qa'):
+        return None
+    item, owner, owner_dir = found
+    role, running = item['role'], item['state'] == 'running'
+    # A finished execution's log is its copy; the owner dir's is the one being written, or the next one's.
+    rel = posixpath.join(owner_dir, role + '.log') if running else f'{item.rel}/{role}.log'
+    log = None
+    try:
+        real = Path(os.path.realpath(reader.path / rel))
+        if executions.inside(reader.path, str(real)) and stat.S_ISREG(real.stat().st_mode):
+            log = real
+        elif real.exists():
+            reader.warn(rel, 'outside the run dir or not a regular file')
+    except (OSError, ValueError):
+        pass
+    resolved = executions.resolved_of(reader, f'{item.rel}/{role}.resolved')
+    if resolved is None and running:
+        resolved = executions.parse_resolved(reader.text(posixpath.join(owner_dir, role + '.resolved'))) or None
+    model = item['model'] or {}
+    result = transcripts.transcript(log, model.get('harness'), running)
+    result.update(run=run_key(reader.path), execution=name, role=role, state=item['state'], attempt=item['attempt'],
+                  spec=model.get('spec'), harness=model.get('harness'), repo=(resolved or {}).get('repo') or None,
+                  owner=owner, warnings=reader.warnings + result['warnings'])
+    return result
+
+
 def final_review_detail(path, name, source='plan'):
     """FinalReviewDetail of final-review-<e>-<p> or integrate-<e>-<p>, or None."""
     reader = _Read(path)
@@ -1028,8 +1066,8 @@ def _diff_detail(reader, key, origin, sources, loaded, reason, reviews):
     found = []
     for review in reviews:
         text = reader.text(review['last']) if review['last'] else None
-        for item in findings.listing(text) or []:
-            found.append(dict(review={key: review[key] for key in ('kind', 'execution', 'attempt', 'spec')},
+        for index, item in enumerate(findings.listing(text) or []):
+            found.append(dict(id=_finding_id(review, index), review={key: review[key] for key in ('kind', 'execution', 'attempt', 'spec')},
                               severity=item['severity'], status=item['status'], location=item['location'],
                               summary=item['summary'], text=item['text']))
     return dict(run=key, source=origin, sources=sources, available=loaded is not None,
@@ -1141,6 +1179,50 @@ def final_review_diff(path, name, source='plan'):
                         _NOT_INLINED if prompted else 'no review prompt yet', [review])
 
 
+# --- findings: every review's findings of a run, for the stage's marks ---------------------
+
+def _finding_id(review, index):
+    """A Finding's id: its review's execution (its kind when it has none) and its place in that reply."""
+    return f"{review['execution'] or review['kind']}:{index}"
+
+
+def _findings_of(reader, review):
+    listed = findings.listing(reader.text(review['last'])) if review['last'] else None
+    return [dict(id=_finding_id(review, index), severity=item['severity'], status=item['status'],
+                 location=item['location'], summary=item['summary'])
+            for index, item in enumerate(listed or [])]
+
+
+def run_findings(path, source='plan'):
+    """RunFindings: each review's Findings, without their text, by task and by final review; None if no run."""
+    reader = _Read(path)
+    kind = _kind(reader.path)
+    if kind is None:
+        return None
+    keys = ('kind', 'execution', 'attempt', 'spec', 'verdict')
+    tasks = []
+    for task_id in ['solo'] if kind == 'solo' else [task['id'] for task in _tasks(reader)]:
+        ctx = _diff_task(reader, task_id)
+        reviews = [dict({key: review[key] for key in keys}, findings=found)
+                   for review in (ctx['reviews'] if ctx else []) for found in [_findings_of(reader, review)] if found]
+        if reviews:
+            tasks.append(dict(id=task_id, reviews=reviews))
+    finals = []
+    if kind == 'plan':
+        items, published = executions.review_dirs(reader)[0], _published(reader)
+        for index, item in enumerate(items[:_MAX_REVIEWS]):
+            summary = _final_review(reader, item, index == 0, published)[0]
+            # the same review final_review_diff pins, so a Finding's id opens it there
+            review = _diff_review('final', None, None, summary['spec'], summary['verdict'], item[3] + '/qa.last', [],
+                                  summary['execution'])
+            found = _findings_of(reader, review)
+            if found:
+                finals.append(dict(name=item[0], execution=summary['execution'], spec=summary['spec'],
+                                   verdict=summary['verdict'], findings=found))
+    return dict(run=run_key(reader.path), available=findings.available(), tasks=tasks, final_reviews=finals,
+                truncated=reader.truncated, warnings=reader.warnings)
+
+
 # --- files: who planned, changed, drifted into or conflicted on each file --------------------
 
 _MAX_FILES, _MAX_TASKS, _MAX_OVERLAPS = 2000, 300, 5000
@@ -1316,12 +1398,18 @@ class Catalog:
     def execution_diff(self, key, name):
         return self._find(key, execution_diff, name)
 
+    def transcript(self, key, name):
+        return self._find(key, execution_transcript, name)
+
     def final_review_diff(self, key, name):
         return self._find(key, final_review_diff, name)
 
     def files(self, key):
         return self._find(key, files_detail)
 
+    def findings(self, key):
+        return self._find(key, run_findings)
+
     def fractal(self, key, task_id):
         return self._find(key, fractal_detail, task_id)
 

package/ui/forge_ui/server.py

@@ -28,16 +28,19 @@ _EXEC_PATH = re.compile(r'/api/runs/([0-9a-f]{12})/executions/((?:task|dwarf|qa|
 _REVIEW_PATH = re.compile(r'/api/runs/([0-9a-f]{12})/final-reviews/((?:final-review|integrate)-[0-9]+-[0-9]+)')
 _TASK_DIFF_PATH = re.compile(_TASK_PATH.pattern + r'/diff(?:/(current|prev|committed|existing))?')
 _EXEC_DIFF_PATH = re.compile(_EXEC_PATH.pattern + '/diff')
+_TRANSCRIPT_PATH = re.compile(_EXEC_PATH.pattern + '/transcript')
 _REVIEW_DIFF_PATH = re.compile(_REVIEW_PATH.pattern + '/diff')
 _FILES_PATH = re.compile(r'/api/runs/([0-9a-f]{12})/files')
+_FINDINGS_PATH = re.compile(r'/api/runs/([0-9a-f]{12})/findings')
 _EXPORT_PATH = re.compile(r'/api/runs/([0-9a-f]{12})/export')
 _FRACTAL_PATH = re.compile(_TASK_PATH.pattern + r'/fractal(?:/nodes/([A-Za-z0-9][A-Za-z0-9_-]{0,100})(/diff)?)?')
-_STATIC_PATH = re.compile(r'/([A-Za-z0-9_.-]+\.(?:html|js|css|svg))')
+_STATIC_PATH = re.compile(r'/([A-Za-z0-9_.-]+\.(?:html|js|css|svg|woff2))')
 _TYPES = {
     'html': 'text/html; charset=utf-8',
     'js': 'text/javascript; charset=utf-8',
     'css': 'text/css; charset=utf-8',
     'svg': 'image/svg+xml',
+    'woff2': 'font/woff2',
 }
 _JSON = 'application/json; charset=utf-8'
 _CSP = ("default-src 'self'; style-src 'self'; script-src 'self'; img-src 'self' data:; "
@@ -106,9 +109,15 @@ def api_get(catalog, path):
     match = _REVIEW_DIFF_PATH.fullmatch(path)
     if match:
         return catalog.final_review_diff(*match.groups())
+    match = _TRANSCRIPT_PATH.fullmatch(path)
+    if match:
+        return catalog.transcript(*match.groups())
     match = _FILES_PATH.fullmatch(path)
     if match:
         return catalog.files(match.group(1))
+    match = _FINDINGS_PATH.fullmatch(path)
+    if match:
+        return catalog.findings(match.group(1))
     match = _FRACTAL_PATH.fullmatch(path)
     if match:
         key, task_id, node, diff = match.group(1), _task_id(match.group(2)), match.group(3), match.group(4)