taskuary 0.2.0__py3-none-any.whl

taskuary/__init__.py

@@ -0,0 +1,2 @@
+"""Taskuary - Automate your job: AI triage in, coding agents out, you in charge."""
+__version__ = '0.2.0'

taskuary/agents.py

@@ -0,0 +1,218 @@
+"""Agent execution: any CLI is an agent. A profile ({cmd, args, resume_args, timeout, cwd,
+cwd_map}) turns Claude Code, Codex, or your own wrapper into a Taskuary teammate: prompt
+over STDIN (argv length limits are real on Windows), JSON output parsed when available
+(Claude-style {result, session_id} -> resumable sessions), git diff captured around the
+run so code changes are first-class, every run traced + audited.
+"""
+import json, os, re, shutil, subprocess, threading, time
+from datetime import datetime
+from loguru import logger
+
+from .store import task_ref
+
+
+def _git(cwd, *args):
+    try:
+        p = subprocess.run(['git', '-C', cwd or os.getcwd(), *args], capture_output=True, text=True,
+                           encoding='utf-8', errors='replace', timeout=30)
+        return p.stdout.strip() if p.returncode == 0 else ''
+    except Exception:
+        return ''
+
+
+def parse_cli_json(stdout: str):
+    """Claude-style single JSON object -> (result, session_id); plain text falls through."""
+    try:
+        j = json.loads((stdout or '').strip())
+        return (j.get('result') or '').strip(), j.get('session_id')
+    except (ValueError, AttributeError):
+        return (stdout or '').strip(), None
+
+
+def _fresh_path() -> str:
+    """PATH as it is NOW, not as it was when Taskuary started. A process keeps the environment
+    it was born with, so a CLI installed while the app was running said "command not found"
+    until a restart - the one thing the error told you to do that you should not have to.
+    Windows keeps the live value in the registry; elsewhere the inherited PATH is all there is."""
+    if os.name != 'nt': return os.environ.get('PATH', '')
+    import winreg
+    parts = [os.environ.get('PATH', '')]
+    for hive, key in ((winreg.HKEY_CURRENT_USER, 'Environment'),
+                      (winreg.HKEY_LOCAL_MACHINE, r'SYSTEM\CurrentControlSet\Control\Session Manager\Environment')):
+        try:
+            with winreg.OpenKey(hive, key) as k:
+                parts.append(os.path.expandvars(winreg.QueryValueEx(k, 'Path')[0]))
+        except OSError:
+            pass
+    return os.pathsep.join(p for p in parts if p)
+
+
+def _shim_target(path: str) -> list:
+    """What an npm .CMD shim actually runs. The shim is four lines of batch around one real
+    program - claude.CMD ends with "%dp0%\node_modules\@anthropic-ai\claude-code\bin\claude.exe" %* -
+    and going through cmd /c to reach it is what costs us the prompt: cmd.exe owns & | < > and
+    stray quotes, so the first prompt cannot be passed as an ARGUMENT and has to be TYPED into
+    the TUI instead, in 160-char bites that a busy input loop drops. Spawn the target directly
+    and the prompt travels as argv - atomically, or not at all. [] = could not tell, use cmd."""
+    try: txt = open(path, encoding='utf-8', errors='replace').read()
+    except OSError: return []
+    here = os.path.dirname(path)
+    found = []
+    for tok in re.findall(r'"([^"]+)"', txt):
+        real = os.path.normpath(tok.replace('%dp0%', here).replace('%~dp0', here))
+        if os.path.isfile(real) and real.lower().endswith(('.exe', '.js')): found.append(real)
+    exe = next((f for f in found if f.lower().endswith('.exe')), None)
+    js = next((f for f in found if f.lower().endswith('.js')), None)
+    if exe and js: return [exe, js]          # node.exe + the cli script
+    if exe: return [exe]
+    if js:
+        node = shutil.which('node')
+        return [node, js] if node else []
+    return []
+
+
+def _resolve_cmd(name: str) -> list:
+    """Windows can't CreateProcess a bare 'claude': npm installs it as claude.cmd, which only
+    PATH-resolves via which(). Reaching THROUGH the shim beats running it under cmd /c - see
+    _shim_target for why that difference decides whether a prompt arrives whole."""
+    path = shutil.which(name) or shutil.which(name, path=_fresh_path())
+    if not path:
+        raise FileNotFoundError(f"'{name}' not found on PATH - is the CLI installed?")
+    if os.name == 'nt' and path.lower().endswith(('.cmd', '.bat')):
+        return _shim_target(path) or ['cmd', '/c', path]
+    return [path]
+
+
+def _fmt_input(inp) -> str:
+    """The one field a human wants to see per tool call - command, path, pattern…"""
+    if not isinstance(inp, dict): return str(inp)[:140]
+    for k in ('command', 'file_path', 'path', 'pattern', 'url', 'query', 'description', 'prompt'):
+        if inp.get(k): return str(inp[k])[:140]
+    return json.dumps(inp)[:140]
+
+
+def _result_text(c) -> str:
+    """A tool_result's content is a string or a list of {type: text} blocks."""
+    v = c.get('content')
+    if isinstance(v, list): v = ' '.join(str(b.get('text') or '') for b in v if isinstance(b, dict))
+    return re.sub(r'\s*\n\s*', ' ⏎ ', str(v or '').strip())
+
+
+def _live_line(j):
+    """One readable console line per claude stream-json event; None = not worth showing.
+    Tool RESULTS stream too (trimmed), so the console reads like the terminal you'd see
+    if you ran the CLI yourself - not just the commands it fired."""
+    t = j.get('type')
+    if t == 'system':
+        # only the real session init is news; the other system events (hooks, compaction,
+        # subagent starts) repeated 'session started' forever and said nothing
+        if j.get('subtype') not in (None, 'init'): return None
+        m = j.get('model') or (j.get('modelInfo') or {}).get('name') or ''
+        return 'session started' + (f' · model {m}' if m else '')
+    if t == 'assistant':
+        out = []
+        for c in (j.get('message') or {}).get('content') or []:
+            if c.get('type') == 'tool_use': out.append(f"→ {c.get('name')}: {_fmt_input(c.get('input'))}")
+            elif c.get('type') == 'text' and (c.get('text') or '').strip(): out.append(c['text'].strip()[:300])
+        return '\n'.join(out) or None
+    if t == 'user':
+        res = [c for c in (j.get('message') or {}).get('content') or []
+               if isinstance(c, dict) and c.get('type') == 'tool_result']
+        if not res: return None
+        if any(c.get('is_error') for c in res): return f"✗ {_result_text(next(c for c in res if c.get('is_error')))[:300]}"
+        txt = _result_text(res[0])
+        return f'· {txt[:240]}' if txt else None
+    return None
+
+
+def run_cli(profile: dict, prompt: str, trace, resume: str = None):
+    """One headless invocation of the configured CLI, output STREAMED line by line into
+    the run trace so the Board shows the agent working live. claude's stream-json events
+    render as readable tool/text lines; any other CLI's plain stdout streams as-is.
+    Returns (result, session_id, diff)."""
+    name = profile.get('cmd', 'claude')
+    cmd = _resolve_cmd(name) + list(profile.get('args') or ['-p'])
+    # which model works it: profile default, or a per-run override from the UI. The flag
+    # name is configurable because every CLI spells it differently (claude/codex: --model).
+    if profile.get('model'): cmd += [profile.get('model_arg') or '--model', str(profile['model'])]
+    if resume and profile.get('resume_args'): cmd += list(profile['resume_args']) + [resume]
+    cwd = profile.get('cwd')
+    head0 = _git(cwd, 'rev-parse', 'HEAD')
+    trace('prompt', 'prompt_sent_to_agent', prompt)
+    trace('tool', 'cli', f'{name} cwd={cwd or os.getcwd()}' + (f' resume={resume}' if resume else ''))
+    p = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                         text=True, encoding='utf-8', errors='replace', cwd=cwd, shell=False)
+    timed = threading.Event()
+    killer = threading.Timer(profile.get('timeout', 1200), lambda: (timed.set(), p.kill()))
+    killer.start()
+    err_buf = []
+    threading.Thread(target=lambda: err_buf.append(p.stderr.read()), daemon=True).start()
+    # stdin feed on its own thread: writing a big prompt while the child is already
+    # emitting output can deadlock both pipes otherwise
+    def _feed():
+        try: p.stdin.write(prompt); p.stdin.close()
+        except Exception: pass
+    threading.Thread(target=_feed, daemon=True).start()
+    raw, final = [], None
+    try:
+        for line in p.stdout:
+            line = line.rstrip('\n')
+            if not line.strip(): continue
+            raw.append(line)
+            try: j = json.loads(line)
+            except ValueError: trace('live', name, line[:400]); continue
+            if isinstance(j, dict) and (j.get('type') == 'result' or ('result' in j and 'type' not in j)):
+                final = j; continue
+            shown = _live_line(j) if isinstance(j, dict) else None
+            if shown: trace('live', name, shown)
+        p.wait()
+    finally:
+        killer.cancel()
+    if p.returncode != 0:
+        why = f'timed out after {profile.get("timeout", 1200)}s' if timed.is_set() else \
+            ((err_buf[0] if err_buf else '') or '\n'.join(raw[-5:]) or 'no output')[:500]
+        raise RuntimeError(f'{name} exit {p.returncode}: {why}')
+    if final is not None: out, sid = str(final.get('result') or '').strip(), final.get('session_id')
+    else: out, sid = parse_cli_json('\n'.join(raw))
+    trace('output', name, out[-1000:])
+    diff = ''
+    if head0:
+        head1 = _git(cwd, 'rev-parse', 'HEAD')
+        if head1 and head1 != head0: diff = _git(cwd, 'diff', f'{head0}..{head1}')
+        unc = _git(cwd, 'diff', 'HEAD')
+        if unc: diff = f'{diff}\n{unc}'.strip()
+        if diff: trace('tool', 'code_changes', f'{len(diff.splitlines())} diff lines captured')
+    return out, sid, (diff[:150000] or None)
+
+
+def task_context(store, task_id: int) -> str:
+    d = store.task_detail(task_id)
+    t = d['task']
+    lines = [f"Task {d['ref']}: {t.get('Title')}", f"Kind: {t.get('Kind')}  Status: {t.get('Status')}",
+             f"Summary: {t.get('Summary') or ''}", '', 'Messages:']
+    for m in d['messages']:
+        lines += [f"- [{m.get('SentAt')}] {m.get('FromName') or m.get('FromEmail')}: {m.get('Subject') or ''}",
+                  f"  {str(m.get('BodyText') or '')[:1500]}"]
+    lines += ['', 'Thread:'] + [f"- {c.get('Actor')}: {str(c.get('Body'))[:300]}" for c in d['comments']]
+    return '\n'.join(lines)
+
+
+def memory_block(store, messages: list) -> str:
+    senders = {(m.get('FromEmail') or '').lower() for m in messages if m.get('FromEmail')}
+    domains = {s.rsplit('@', 1)[-1] for s in senders if '@' in s}
+    hits = [f"- {n['Note']}" for n in store.list_memories()
+            if n['Scope'] == 'global' or (n['Scope'] == 'sender' and (n.get('ScopeKey') or '').lower() in senders)
+            or (n['Scope'] == 'sender_domain' and (n.get('ScopeKey') or '').lower() in domains)]
+    return ('Standing notes (learned from the owner - FOLLOW these):\n' + '\n'.join(hits)) if hits else ''
+
+
+# dispatch() lived here: one open->close HEADLESS run on a task, the CLI working and closing
+# where nobody could watch it, interrupt it or answer it. That is precisely the thing this app
+# exists to replace, and every road that used it now opens a REAL session instead
+# (terminal.start_on_task) or, for a two-sentence reply, asks the main AI directly
+# (responder.write_draft). It is deleted rather than left dormant: a headless runner sitting
+# in the module is a headless runner somebody wires back up.
+#
+# run_cli above STAYS, and is not the same thing: it is a one-shot "ask this CLI a question"
+# used as a cheap BRAIN (llm.make_cli_llm - triage, drafts, summaries on an agent's light
+# model) and by the connector test. No task, no run row, no work performed.

taskuary/artifacts.py

@@ -0,0 +1,209 @@
+"""Report output you can actually use: the spreadsheet and the chart, not just the prose.
+
+A report already produces ROWS - the message body is one JSON object per line - so the same
+run can hand back an .xlsx to open in Excel and an .svg chart to look at in the panel. Both
+are written as attachments on the report message, which means the timeline and the task page
+already know how to show them (images inline, files as chips).
+
+Both writers are hand-rolled on the standard library on purpose: xlsx is a zip of four small
+XML parts, and a bar chart is a few dozen rects. Neither is worth a dependency that has to be
+frozen into the one-file exe.
+"""
+import json, re, zipfile
+from datetime import datetime
+from xml.sax.saxutils import escape
+
+MAX_SHEET_ROWS, MAX_COLS, MAX_BARS = 5000, 40, 24
+_SAFE = re.compile(r'[^A-Za-z0-9._ -]+')
+
+
+def attachment_dir(mid: int):
+    """Where a message's files live. One folder per message, so deleting a message's bytes is
+    deleting a folder."""
+    from . import config
+    p = config.home() / 'attachments' / str(int(mid))
+    p.mkdir(parents=True, exist_ok=True)
+    return p
+
+
+def rows_from_body(text: str) -> list:
+    """The rows back out of a report body (one JSON object per line). Anything that is not a
+    JSON object is prose - a summary, an error - and is not data."""
+    out = []
+    for l in (text or '').splitlines():
+        l = l.strip()
+        if not l.startswith('{'): continue
+        try:
+            d = json.loads(l)
+            if isinstance(d, dict): out.append(d)
+        except ValueError:
+            pass
+    return out[:MAX_SHEET_ROWS]
+
+
+def columns(rows: list) -> list:
+    """Every key any row has, in the order they first appear - SQL rows are uniform, REST rows
+    are not, and a missing key must not shift a column."""
+    cols = []
+    for r in rows:
+        for k in r:
+            if k not in cols: cols.append(k)
+    return cols[:MAX_COLS]
+
+
+def _cell(ref: str, v) -> str:
+    # a missing value writes NO cell (refs are explicit, so nothing shifts): an empty inline
+    # string is a value, and Excel treats "" and blank differently in counts and filters
+    if v is None or v == '': return ''
+    if isinstance(v, bool): v = str(v)
+    if isinstance(v, (int, float)):
+        return f'<c r="{ref}"><v>{v}</v></c>'
+    s = json.dumps(v, default=str) if isinstance(v, (dict, list)) else str(v)
+    return f'<c r="{ref}" t="inlineStr"><is><t xml:space="preserve">{escape(s)}</t></is></c>'
+
+
+def _col_name(i: int) -> str:
+    s = ''
+    while True:
+        s, i = chr(65 + i % 26) + s, i // 26 - 1
+        if i < 0: return s
+
+
+def to_xlsx(rows: list, path, sheet: str = 'Report') -> bool:
+    """Minimal but real xlsx: header row bold-free, inline strings, numbers as numbers so Excel
+    sums them. Returns False when there is nothing tabular to write."""
+    if not rows: return False
+    cols = columns(rows)
+    xml = ['<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'
+           '<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"><sheetData>']
+    xml.append('<row r="1">' + ''.join(_cell(f'{_col_name(i)}1', c) for i, c in enumerate(cols)) + '</row>')
+    for n, r in enumerate(rows, start=2):
+        xml.append(f'<row r="{n}">' + ''.join(_cell(f'{_col_name(i)}{n}', r.get(c)) for i, c in enumerate(cols)) + '</row>')
+    xml.append('</sheetData></worksheet>')
+    name = escape(_SAFE.sub('', str(sheet))[:31] or 'Report')
+    with zipfile.ZipFile(path, 'w', zipfile.ZIP_DEFLATED) as z:
+        z.writestr('[Content_Types].xml',
+                   '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'
+                   '<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">'
+                   '<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>'
+                   '<Default Extension="xml" ContentType="application/xml"/>'
+                   '<Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>'
+                   '<Override PartName="/xl/worksheets/sheet1.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>'
+                   '</Types>')
+        z.writestr('_rels/.rels',
+                   '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'
+                   '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">'
+                   '<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/>'
+                   '</Relationships>')
+        z.writestr('xl/workbook.xml',
+                   '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'
+                   '<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" '
+                   'xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">'
+                   f'<sheets><sheet name="{name}" sheetId="1" r:id="rId1"/></sheets></workbook>')
+        z.writestr('xl/_rels/workbook.xml.rels',
+                   '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'
+                   '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">'
+                   '<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet1.xml"/>'
+                   '</Relationships>')
+        z.writestr('xl/worksheets/sheet1.xml', ''.join(xml))
+    return True
+
+
+def _num(v):
+    if isinstance(v, bool) or v is None: return None
+    if isinstance(v, (int, float)): return float(v)
+    try: return float(str(v).replace(',', '').replace('$', '').strip())
+    except ValueError: return None
+
+
+_CHART_LINE = re.compile(r'^[ \t]*CHART:[ \t]*([^|\r\n]+?)[ \t]*(?:\|[ \t]*([^\r\n]*))?$', re.M | re.I)
+
+def chart_directive(text: str) -> tuple:
+    """(value column, label column, title) if the summary asked for a particular chart. The AI
+    has just read every row, so it knows which column is the measure and which is the name -
+    better than a heuristic scanning for "all numeric". Format: `CHART: amount | vendor | Spend
+    by vendor`. Absent, or naming a column that is not there, falls back to the guess."""
+    mt = _CHART_LINE.search(text or '')
+    if not mt: return None, None, ''
+    bits = [b.strip() for b in ((mt.group(1) or '') + '|' + (mt.group(2) or '')).split('|')]
+    return (bits[0] or None), (bits[1] if len(bits) > 1 and bits[1] else None), (bits[2] if len(bits) > 2 else '')
+
+
+def strip_directive(text: str) -> str:
+    """The CHART: line is an instruction to Taskuary, not prose for the reader."""
+    return _CHART_LINE.sub('', text or '').strip()
+
+
+def chart_columns(rows: list) -> tuple:
+    """(label column, value column) - the first column that reads as a name, and the first that
+    reads as a number in every row. No numbers means no chart; a table of ids and strings is not
+    a chart just because we can draw axes."""
+    cols = columns(rows)
+    vals = [c for c in cols if all(_num(r.get(c)) is not None for r in rows if c in r)
+            and any(_num(r.get(c)) for r in rows)]
+    labels = [c for c in cols if c not in vals]
+    return ((labels[0] if labels else None), (vals[0] if vals else None))
+
+
+# Taskuary's own indigo, and a chart that reads in both the panel and a screenshot of it.
+def to_svg_chart(rows: list, path, title: str = '', want_val: str = None, want_lab: str = None) -> str:
+    """Horizontal bars: label, bar, value. Horizontal because report labels are names and dates,
+    which do not fit under a vertical bar without turning sideways. Returns the caption, or ''
+    when the rows carry nothing to plot. `want_val`/`want_lab` are the AI's pick, honoured only
+    when the column is really in the rows - a hallucinated column must not lose the chart."""
+    cols = columns(rows)
+    lab, val = chart_columns(rows)
+    if want_val in cols and any(_num(r.get(want_val)) is not None for r in rows): val = want_val
+    if want_lab in cols: lab = want_lab
+    if not val: return ''
+    pts = [(str(r.get(lab, ''))[:42] if lab else f'#{i + 1}', _num(r.get(val)) or 0.0)
+           for i, r in enumerate(rows)][:MAX_BARS]
+    if not pts: return ''
+    top = max(abs(v) for _l, v in pts) or 1.0
+    W, LW, RH, PAD = 760, 210, 22, 18
+    H = PAD * 2 + 26 + RH * len(pts)
+    out = [f'<svg xmlns="http://www.w3.org/2000/svg" width="{W}" height="{H}" viewBox="0 0 {W} {H}" '
+           f'font-family="Segoe UI, Helvetica, Arial, sans-serif">',
+           f'<rect width="{W}" height="{H}" fill="#ffffff"/>',
+           f'<text x="{PAD}" y="{PAD + 12}" font-size="13" font-weight="700" fill="#1f2430">'
+           f'{escape(title or val)}</text>',
+           f'<text x="{W - PAD}" y="{PAD + 12}" font-size="10" fill="#8a94a6" text-anchor="end">'
+           f'{escape(val)} by {escape(lab or "row")} · {len(pts)} of {len(rows)}</text>']
+    bar_w = W - LW - PAD * 2 - 60
+    for i, (l, v) in enumerate(pts):
+        y = PAD + 26 + i * RH
+        w = max(1, int(bar_w * abs(v) / top))
+        out += [f'<text x="{LW}" y="{y + 14}" font-size="11" fill="#697386" text-anchor="end">{escape(l)}</text>',
+                f'<rect x="{LW + 8}" y="{y + 4}" width="{w}" height="{RH - 9}" rx="2" fill="#4f46e5" fill-opacity="0.85"/>',
+                f'<text x="{LW + 14 + w}" y="{y + 14}" font-size="10.5" fill="#1f2430">'
+                f'{escape(f"{v:,.2f}".rstrip("0").rstrip("."))}</text>']
+    out.append('</svg>')
+    svg = ''.join(out)
+    if path is not None: path.write_text(svg, encoding='utf-8')
+    return svg if path is None else f'{val} by {lab or "row"}'
+
+
+XLSX_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+
+def attach_report_output(store, mid: int, title: str, body: str) -> list:
+    """Turn one report's rows into files on its message: the spreadsheet, and the chart when the
+    data has a measure in it. Prose-only reports (an AI summary, a failure) produce neither, and
+    `report_images_enabled` = 0 turns the chart off without losing the spreadsheet."""
+    rows = rows_from_body(body)
+    if not rows: return []
+    want_val, want_lab, want_title = chart_directive(body)
+    charts_on = str(store.get_settings().get('report_images_enabled') or '1') == '1'
+    stem = _SAFE.sub('', title or 'report').strip()[:60] or 'report'
+    day = datetime.now().strftime('%Y-%m-%d')
+    made = []
+    d = attachment_dir(mid)
+    x = d / f'{stem} {day}.xlsx'
+    if to_xlsx(rows, x, stem[:31]):
+        made.append(store.add_attachment({'MessageId': mid, 'ExternalId': f'report:{mid}:xlsx', 'Name': x.name,
+                                          'ContentType': XLSX_TYPE, 'Size': x.stat().st_size, 'Path': str(x)}))
+    c = d / f'{stem} {day}.svg'
+    if charts_on and to_svg_chart(rows, c, want_title or stem, want_val, want_lab):
+        made.append(store.add_attachment({'MessageId': mid, 'ExternalId': f'report:{mid}:chart', 'Name': c.name,
+                                          'ContentType': 'image/svg+xml', 'Size': c.stat().st_size,
+                                          'Inline': 1, 'Path': str(c)}))
+    return made