@capagents/forgeqe 1.0.3 → 1.0.5

package/src/tui/refine-panel.tsx

@@ -0,0 +1,94 @@
+import type { Refined } from "../refine.ts"
+import { Spinner } from "./components.tsx"
+import { theme } from "./theme.ts"
+
+/** Refine's panel, in the prompt's place: working, the result with what was checked, or why it could not refine. */
+export type RefineState =
+  | { phase: "working"; original: string }
+  | { phase: "done"; original: string; result: Refined; choice: number }
+  | { phase: "error"; original: string; message: string }
+
+export const REFINE_CHOICES = [
+  { id: "use", label: "Use refined", key: "enter" },
+  { id: "edit", label: "Edit", key: "e" },
+  { id: "keep", label: "Keep mine", key: "esc" },
+] as const
+
+export type RefineChoice = (typeof REFINE_CHOICES)[number]["id"]
+
+const COLOR = theme.memory
+
+export function RefinePanel(props: { state: RefineState; width: number; onChoose: (id: RefineChoice) => void; onHover: (i: number) => void }) {
+  const { state, width } = props
+  const title = state.phase === "working" ? " ✦ Refining " : state.phase === "error" ? " ✦ Could not refine " : " ✦ Refined request "
+  const section = (label: string, color: string, mark: string, items: string[]) =>
+    items.length ? (
+      <box style={{ flexDirection: "column", marginTop: 1 }}>
+        <text fg={theme.muted}>{label}</text>
+        {items.map((it, i) => (
+          <box key={i} style={{ flexDirection: "row" }}>
+            <text fg={color} style={{ width: 2, flexShrink: 0 }}>
+              {mark}
+            </text>
+            <text fg={theme.text} style={{ flexGrow: 1, flexShrink: 1 }}>
+              {it}
+            </text>
+          </box>
+        ))}
+      </box>
+    ) : null
+  return (
+    <box style={{ flexDirection: "column", width, flexShrink: 0 }}>
+      <box border borderStyle="rounded" borderColor={COLOR} title={title} titleColor={COLOR} style={{ flexDirection: "column", paddingLeft: 1, paddingRight: 1, backgroundColor: theme.panel }}>
+        {state.phase === "working" ? (
+          <box style={{ flexDirection: "row" }}>
+            <Spinner kind="dots" color={COLOR} />
+            <text fg={theme.muted}>{" Checking your request against this setup: capabilities, systems, project, recent runs…"}</text>
+          </box>
+        ) : state.phase === "error" ? (
+          <text fg={theme.err}>{state.message}</text>
+        ) : (
+          <>
+            <text fg={theme.text}>{state.result.refined}</text>
+            {section("Checked", theme.ok, "✓", state.result.grounded.filter((g) => g.checked).map((g) => g.fact))}
+            {section("Assumed", theme.warn, "~", [...state.result.grounded.filter((g) => !g.checked).map((g) => g.fact), ...state.result.assumed])}
+            {section("Missing — answer these in your request", theme.err, "?", state.result.missing)}
+          </>
+        )}
+      </box>
+      <box style={{ flexDirection: "row", justifyContent: "space-between", height: 1, marginTop: 0 }}>
+        {state.phase === "done" ? (
+          <box style={{ flexDirection: "row" }}>
+            {REFINE_CHOICES.map((c, i) => {
+              const active = i === state.choice
+              return (
+                <box key={c.id} onMouseDown={() => props.onChoose(c.id)} onMouseOver={() => props.onHover(i)} style={{ paddingLeft: 1, paddingRight: 1, marginRight: 1, backgroundColor: active ? COLOR : theme.button }}>
+                  <text fg={active ? theme.onButton : theme.muted}>{c.label}</text>
+                </box>
+              )
+            })}
+          </box>
+        ) : (
+          <text fg={theme.faint}>{state.phase === "working" ? "" : "Your request is back in the prompt."}</text>
+        )}
+        <text>
+          {state.phase === "done" ? (
+            <>
+              <span fg={theme.text}>{"enter"}</span>
+              <span fg={theme.muted}>{" use  "}</span>
+              <span fg={theme.text}>{"e"}</span>
+              <span fg={theme.muted}>{" edit  "}</span>
+              <span fg={theme.text}>{"esc"}</span>
+              <span fg={theme.muted}>{" keep mine"}</span>
+            </>
+          ) : (
+            <>
+              <span fg={theme.text}>{"esc"}</span>
+              <span fg={theme.muted}>{state.phase === "working" ? " cancel" : " close"}</span>
+            </>
+          )}
+        </text>
+      </box>
+    </box>
+  )
+}

package/src/tui/setup.ts

@@ -0,0 +1,37 @@
+import type { AppConfig } from "../config.ts"
+import { MACHINE, requirementGap, type Probes } from "../capabilities/status.ts"
+import type { Requirement } from "../capabilities/registry.ts"
+
+/**
+ * The home screen's setup checklist: the few things most features rest on, each checked the way the capability
+ * registry checks a requirement, so the checklist and /features never disagree.
+ */
+export type SetupItem = {
+  id: "model" | "agent" | "system" | "domain" | "notify"
+  label: string
+  done: boolean
+  /** What is missing, and how to set it up: shown when the item is chosen. */
+  fix?: string
+  /** A command that sets it up, run when the item is chosen. */
+  command?: string
+}
+
+const CHECKS: { id: SetupItem["id"]; label: string; requirement: Requirement; command?: string }[] = [
+  { id: "model", label: "Model", requirement: { kind: "live_model" } },
+  { id: "agent", label: "Coding agent", requirement: { kind: "coding_agent" } },
+  { id: "system", label: "Work items", requirement: { kind: "system", anyOf: ["azure_devops", "jira", "testrail", "zephyr", "qtest", "xray"] }, command: "/auth" },
+  { id: "domain", label: "Domain", requirement: { kind: "domain" } },
+  { id: "notify", label: "Notifications", requirement: { kind: "notify_channels" } },
+]
+
+export function setupChecklist(cfg: AppConfig, probes: Probes = MACHINE): SetupItem[] {
+  return CHECKS.map((c) => {
+    const gap = requirementGap(c.requirement, cfg, probes)
+    return {
+      id: c.id,
+      label: c.label,
+      done: !gap,
+      ...(gap ? { fix: `${c.label}: ForgeQE needs ${gap.missing}. To set it up, ${gap.fix}.`, ...(c.command ? { command: c.command } : {}) } : {}),
+    }
+  })
+}

package/src/tui/suggest.ts

@@ -0,0 +1,111 @@
+import { spawnSync } from "node:child_process"
+import { existsSync, readdirSync, readFileSync } from "node:fs"
+import path from "node:path"
+
+import { adoSettings } from "../cases/ado.ts"
+import { http } from "../cases/http.ts"
+import type { AppConfig } from "../config.ts"
+import type { PaletteItem } from "./palette.tsx"
+
+/**
+ * Suggestions while typing: "/" completes a command, "@" a reference to something real (a recent run, a file in the
+ * repository, an Azure DevOps work item looked up by its id). Nothing is suggested that does not exist.
+ */
+
+export type Suggestion = { kind: "command" | "run" | "file" | "item"; label: string; detail?: string; insert: string }
+
+/** What is being completed: a command at the start of the prompt, or the "@" word being typed at its end. */
+export type Trigger = { kind: "/" | "@"; token: string; start: number }
+
+export function triggerAt(text: string): Trigger | null {
+  if (/^\/\S*$/.test(text)) return { kind: "/", token: text.slice(1), start: 0 }
+  const m = /(^|\s)@(\S*)$/.exec(text)
+  return m ? { kind: "@", token: m[2]!, start: m.index + m[1]!.length } : null
+}
+
+/** The prompt with the trigger's word replaced by the completion, ready for more typing. */
+export function complete(text: string, t: Trigger, insert: string): string {
+  return `${text.slice(0, t.start)}${insert} `
+}
+
+export function commandSuggestions(items: PaletteItem[], token: string): Suggestion[] {
+  const seen = new Set<string>()
+  const out: Suggestion[] = []
+  for (const item of items) {
+    if (item.run.kind !== "command" || seen.has(item.run.text)) continue
+    seen.add(item.run.text)
+    out.push({ kind: "command", label: item.run.text, detail: item.title, insert: item.run.text })
+  }
+  const t = token.toLowerCase()
+  return out.filter((s) => s.label.slice(1).toLowerCase().startsWith(t)).concat(out.filter((s) => !s.label.slice(1).toLowerCase().startsWith(t) && s.label.toLowerCase().includes(t)))
+}
+
+export type RecentRun = { id: string; dir: string; goal: string }
+
+/** The newest run folders (named by their start time) with their goals. */
+export function recentRuns(outDir: string, limit = 8): RecentRun[] {
+  if (!existsSync(outDir)) return []
+  return readdirSync(outDir)
+    .filter((d) => /^\d{8}-\d{6}(-\d+)?$/.test(d))
+    .sort()
+    .reverse()
+    .slice(0, limit)
+    .map((id) => {
+      let goal = ""
+      try {
+        goal = String(JSON.parse(readFileSync(path.join(outDir, id, "run.json"), "utf8")).goal || "")
+      } catch {}
+      return { id, dir: path.join(outDir, id), goal }
+    })
+}
+
+const filesCache = new Map<string, string[]>()
+
+/** The repository's tracked files (git ls-files), once per folder; none outside a git repository. */
+export function repoFiles(cwd: string): string[] {
+  const known = filesCache.get(cwd)
+  if (known) return known
+  const r = spawnSync("git", ["ls-files"], { cwd, encoding: "utf8", maxBuffer: 20_000_000 })
+  const files = r.status === 0 ? r.stdout.split("\n").filter(Boolean).slice(0, 20_000) : []
+  filesCache.set(cwd, files)
+  return files
+}
+
+export type WorkItem = { id: number; title: string; type: string; project: string }
+
+/** What `@` can refer to for the word typed after it. */
+export function referenceSuggestions(token: string, src: { runs: RecentRun[]; files: string[]; item?: WorkItem | null; cwd: string }): Suggestion[] {
+  const t = token.toLowerCase()
+  const out: Suggestion[] = []
+  if (/^\d+$/.test(token)) {
+    if (src.item) out.push({ kind: "item", label: `${src.item.type} ${src.item.id}`, detail: `${src.item.title} · ${src.item.project}`, insert: `Azure DevOps ${src.item.type.toLowerCase()} ${src.item.id} ("${src.item.title}")` })
+    return out
+  }
+  if (!t || "run".startsWith(t) || t.startsWith("run")) {
+    const runs = src.runs.filter((r) => !t.startsWith("run") || t === "run" || r.id.includes(t.slice(3)))
+    for (const [i, r] of runs.entries()) out.push({ kind: "run", label: i === 0 ? "last run" : `run ${r.id}`, detail: r.goal || r.id, insert: `the run in ${path.relative(src.cwd, r.dir) || r.dir}` })
+  }
+  if (t.length >= 2) {
+    const byName = src.files.filter((f) => path.basename(f).toLowerCase().includes(t))
+    const byPath = src.files.filter((f) => !path.basename(f).toLowerCase().includes(t) && f.toLowerCase().includes(t))
+    for (const f of [...byName, ...byPath].slice(0, 8)) out.push({ kind: "file", label: path.basename(f), detail: path.dirname(f) === "." ? "" : path.dirname(f), insert: f })
+  }
+  return out.slice(0, 10)
+}
+
+const itemCache = new Map<number, WorkItem | null>()
+
+/** An Azure DevOps work item's title, type, and project by its id; null when it does not exist or cannot be read. */
+export async function lookupWorkItem(cfg: AppConfig, id: number): Promise<WorkItem | null> {
+  if (itemCache.has(id)) return itemCache.get(id)!
+  let item: WorkItem | null = null
+  try {
+    const { auth, org } = adoSettings(cfg.sources)
+    const { data } = await http<{ id: number; fields: Record<string, unknown> }>(`${org}/_apis/wit/workitems/${id}?fields=System.Title,System.WorkItemType,System.TeamProject&api-version=7.1`, { auth })
+    item = { id: data.id, title: String(data.fields["System.Title"] || ""), type: String(data.fields["System.WorkItemType"] || "Work item"), project: String(data.fields["System.TeamProject"] || "") }
+  } catch {
+    item = null
+  }
+  itemCache.set(id, item)
+  return item
+}

package/src/tui/transcript.tsx

@@ -1,3 +1,5 @@
+import { existsSync } from "node:fs"
+import os from "node:os"
 import path from "node:path"
 import { SyntaxStyle } from "@opentui/core"
 
@@ -147,7 +149,7 @@ export function SummaryCard({ summary }: { summary: RunSummary }) {
       {summary.savedDir ? (
         <text>
           <span fg={theme.faint}>{"Saved     "}</span>
-          <span fg={theme.muted}>{`${summary.savedDir}/  `}</span>
+          <Linked text={`${summary.savedDir}/  `} color={theme.muted} />
           <span fg={theme.faint}>{summary.savedFiles.join(" · ")}</span>
         </text>
       ) : null}
@@ -155,12 +157,54 @@ export function SummaryCard({ summary }: { summary: RunSummary }) {
   )
 }
 
+/** A web address, or a path with at least one folder: what Linked turns into a link when it exists. */
+const LINKABLE = /(https?:\/\/[^\s)"'<>]+|(?:~|\.{1,2})?\/?[\w.@-]+(?:\/[\w.@-]+)+\/?)/g
+
+/** The target of a link: the address itself, or the file's absolute path; null for a path that does not exist. */
+export function linkTarget(token: string, cwd = process.cwd()): string | null {
+  if (/^https?:\/\//.test(token)) return token
+  const file = token.startsWith("~/") ? path.join(os.homedir(), token.slice(2)) : path.resolve(cwd, token)
+  return existsSync(file) ? `file://${file}` : null
+}
+
+/**
+ * Text whose web addresses and existing file paths can be opened from the terminal (OSC 8 links: cmd/ctrl+click in
+ * VS Code and most terminals). A path that does not exist stays plain text, so no link leads nowhere.
+ */
+export function Linked({ text, color }: { text: string; color: string }) {
+  const parts: { text: string; href?: string }[] = []
+  let at = 0
+  for (const m of text.matchAll(LINKABLE)) {
+    const href = linkTarget(m[0])
+    if (!href) continue
+    if (m.index! > at) parts.push({ text: text.slice(at, m.index) })
+    parts.push({ text: m[0], href })
+    at = m.index! + m[0].length
+  }
+  if (at < text.length) parts.push({ text: text.slice(at) })
+  return (
+    <>
+      {parts.map((p, i) =>
+        p.href ? (
+          <a key={i} href={p.href} fg={theme.accent}>
+            {p.text}
+          </a>
+        ) : (
+          <span key={i} fg={color}>
+            {p.text}
+          </span>
+        ),
+      )}
+    </>
+  )
+}
+
 export function Row({ label, value, color = theme.muted }: { label: string; value: string; color?: string }) {
   if (!value) return null
   return (
     <text>
       <span fg={theme.faint}>{label.padEnd(10)}</span>
-      <span fg={color}>{value}</span>
+      <Linked text={value} color={color} />
     </text>
   )
 }
@@ -257,9 +301,7 @@ export function ResultCard({ card }: { card: Card }) {
       </box>
       {card.body.length ? <box style={{ height: 1 }} /> : null}
       {card.body.map((l, i) => (
-        <text key={i} fg={lineColor(l)}>
-          {l || " "}
-        </text>
+        <text key={i}>{l ? <Linked text={l} color={lineColor(l)} /> : " "}</text>
       ))}
     </box>
   )

package/src/usage.ts

@@ -98,7 +98,7 @@ export function usageLine(usage: Usage, cost?: Cost | null): string {
 // The meter: every model session reports here, by role
 // ---------------------------------------------------------------------------------------------
 
-export type Role = "ForgeQE's agent" | "browser agent" | "Scribe" | "reviewer" | "judge"
+export type Role = "ForgeQE's agent" | "browser agent" | "Scribe" | "reviewer" | "judge" | "refiner"
 
 type Entry = { usage: Usage; cost?: Cost; priced: boolean }