@capagents/forgeqe 1.0.7 → 1.0.9

package/src/tui/landing.ts

@@ -0,0 +1,128 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs"
+import path from "node:path"
+
+import type { AppConfig } from "../config.ts"
+import { CAPABILITIES } from "../capabilities/registry.ts"
+import { allStatuses, configuredSystems, SYSTEM_LABEL, type Probes, MACHINE } from "../capabilities/status.ts"
+
+/**
+ * What the start screen shows before the first request: the project it works on, the actions that work in this setup,
+ * and the reports and runs to pick up again. Everything comes from the config, the capability registry, and the files
+ * in the folder, so it changes as the setup changes.
+ */
+
+/** "C# · .NET solution · Playwright Test": what the folder's own files say it is built with. */
+export function projectStack(cwd: string): string[] {
+  let names: string[] = []
+  try {
+    names = readdirSync(cwd)
+  } catch {
+    return []
+  }
+  const has = (re: RegExp) => names.some((n) => re.test(n))
+  const out: string[] = []
+  if (has(/^playwright\.config\.(ts|js|mjs|cjs)$/)) out.push("Playwright Test")
+  if (has(/^cypress\.config\.(ts|js|mjs|cjs)$/)) out.push("Cypress")
+  if (has(/\.sln$/) || has(/\.csproj$/)) out.push(".NET")
+  if (has(/^pom\.xml$/)) out.push("Maven")
+  if (has(/^build\.gradle(\.kts)?$/)) out.push("Gradle")
+  if (has(/^(pytest\.ini|conftest\.py)$/) || (has(/^pyproject\.toml$/) && !out.length)) out.push("Python")
+  if (has(/^package\.json$/) && !out.some((s) => s === "Playwright Test" || s === "Cypress")) out.push("Node")
+  return out.slice(0, 2)
+}
+
+/** The project line: folder, stack, the systems ForgeQE works with here, and the model. */
+export function projectLine(cfg: AppConfig | null, cwd: string, model: string): string[] {
+  const parts = [path.basename(cwd), ...projectStack(cwd)]
+  if (cfg) parts.push(...[...configuredSystems(cfg)].filter((s) => s !== "xray" || !configuredSystems(cfg).has("jira")).map((s) => SYSTEM_LABEL[s]))
+  if (model) parts.push(model)
+  return parts.filter(Boolean)
+}
+
+const ALL_SYSTEMS = Object.values(SYSTEM_LABEL)
+
+export type StartAction = { id: string; label: string; detail: string; request: string }
+
+/**
+ * The first things worth asking, in this order, among the capabilities that work in this setup: work from the systems
+ * first, then what a team asks for most. Each puts its example request in the prompt to adjust.
+ */
+const START_ORDER = ["run-test-cases", "release-readiness", "reports", "exploratory-testing", "write-test-cases", "pr-review", "api-testing", "find-run-tests", "browser-goals"]
+
+const START_LABEL: Record<string, string> = {
+  "run-test-cases": "Run test cases",
+  "release-readiness": "Check release readiness",
+  reports: "Write a report to share",
+  "exploratory-testing": "Explore a story for bugs",
+  "write-test-cases": "Write test cases from a story",
+  "pr-review": "Review a pull request",
+  "api-testing": "Test an API",
+  "find-run-tests": "Run the repository's tests",
+  "browser-goals": "Try a flow in the browser",
+}
+
+export function startActions(cfg: AppConfig | null, limit = 4, probes: Probes = MACHINE): StartAction[] {
+  if (!cfg) return []
+  const statuses = allStatuses(cfg, probes)
+  const systems = [...configuredSystems(cfg)].map((x) => SYSTEM_LABEL[x])
+  const out: StartAction[] = []
+  for (const id of START_ORDER) {
+    const c = CAPABILITIES.find((x) => x.id === id)
+    if (!c || statuses.get(id)?.state === "needs_setup") continue
+    // An example in the words of this setup: one that names a system that is set up, else one that names none.
+    const named = c.examples.find((e) => systems.some((n) => e.includes(n)))
+    const neutral = c.examples.find((e) => !ALL_SYSTEMS.some((n) => e.includes(n)))
+    const example = named || neutral || c.examples[0] || c.title
+    out.push({ id, label: START_LABEL[id] || c.title, detail: example, request: example })
+    if (out.length === limit) break
+  }
+  return out
+}
+
+export type RecentItem = { kind: "report" | "run"; title: string; dir: string; open: string; when: Date; status?: string }
+
+/** The newest reports and runs in the reports folder: what a returning user picks up again. */
+export function recentWork(outDir: string, limit = 3): RecentItem[] {
+  if (!existsSync(outDir)) return []
+  const items: RecentItem[] = []
+  for (const name of readdirSync(outDir)) {
+    const dir = path.join(outDir, name)
+    try {
+      if (!statSync(dir).isDirectory()) continue
+      const when = statSync(dir).mtime
+      if (existsSync(path.join(dir, "run.json"))) {
+        const run = JSON.parse(readFileSync(path.join(dir, "run.json"), "utf8")) as { goal?: string; status?: string }
+        const report = path.join(dir, "report.html")
+        items.push({ kind: "run", title: String(run.goal || name), dir, open: existsSync(report) ? report : dir, when, status: run.status })
+      } else if (existsSync(path.join(dir, "report.md"))) {
+        const first = readFileSync(path.join(dir, "report.md"), "utf8").split("\n")[0] || ""
+        const html = path.join(dir, "report.html")
+        items.push({ kind: "report", title: first.replace(/^#\s*/, "").trim() || name, dir, open: existsSync(html) ? html : path.join(dir, "report.md"), when })
+      }
+    } catch {}
+  }
+  return items.sort((a, b) => b.when.getTime() - a.when.getTime()).slice(0, limit)
+}
+
+/** "just now", "12 min ago", "3 h ago", "yesterday", "4 days ago", then the date. */
+export function ago(when: Date, now = new Date()): string {
+  const s = Math.max(0, (now.getTime() - when.getTime()) / 1000)
+  if (s < 60) return "just now"
+  if (s < 3600) return `${Math.floor(s / 60)} min ago`
+  if (s < 86400) return `${Math.floor(s / 3600)} h ago`
+  if (s < 2 * 86400) return "yesterday"
+  if (s < 7 * 86400) return `${Math.floor(s / 86400)} days ago`
+  return when.toISOString().slice(0, 10)
+}
+
+/** "Domain", "Domain and Notifications", "Model, Domain, and Notifications". */
+export function listWords(words: string[]): string {
+  if (words.length < 3) return words.join(" and ")
+  return `${words.slice(0, -1).join(", ")}, and ${words.at(-1)}`
+}
+
+/** "Domain and Notifications are not set up", or, when the names do not fit in `room`, "5 items are not set up". */
+export function setupSentence(missing: string[], room: number): string {
+  const named = `${listWords(missing)} ${missing.length === 1 ? "is" : "are"} not set up`
+  return named.length <= room ? named : `${missing.length} ${missing.length === 1 ? "item is" : "items are"} not set up`
+}

package/src/tui/palette.tsx

@@ -15,7 +15,7 @@ export type PaletteRun =
   /** Put in the prompt to edit and send: an example request. */
   | { kind: "insert"; text: string }
   /** Something the shell does itself. */
-  | { kind: "action"; id: "refine" | "stop" | "details" | "chat" | "wide" | "panels" }
+  | { kind: "action"; id: "refine" | "stop" | "details" | "chat" | "wide" | "panels" | "shortcuts" }
 
 export type PaletteItem = { id: string; group: PaletteGroup; title: string; detail?: string; keys?: string; run: PaletteRun }
 
@@ -31,6 +31,7 @@ export function paletteItems(opts: { running: boolean; headed: boolean; detailsF
     if (!opts.chatWide) items.push({ id: "panels", group: "Action", title: "Move to the panels: plan, activity, files", keys: "shift+tab", run: { kind: "action", id: "panels" } })
   }
   if (opts.narrow) items.push({ id: "view", group: "Action", title: opts.view === "chat" ? "Show the details view" : "Back to the chat", keys: "ctrl+o", run: { kind: "action", id: opts.view === "chat" ? "details" : "chat" } })
+  items.push({ id: "shortcuts", group: "Action", title: "Keyboard shortcuts", keys: "?", run: { kind: "action", id: "shortcuts" } })
   command("features", "What ForgeQE can do here", "/features", "and what each feature still needs")
   command("auth", "Sign in to a system", "/auth", "Azure DevOps, GitHub, Jira, Confluence, TestRail, Zephyr, qTest, Xray")
   command("auth-status", "What is signed in", "/auth status")

package/src/tui/refine-panel.tsx

@@ -49,7 +49,20 @@ export function RefinePanel(props: { state: RefineState; width: number; onChoose
           <text fg={theme.err}>{state.message}</text>
         ) : (
           <>
-            <text fg={theme.text}>{state.result.refined}</text>
+            {/* The request as it is sent: its labelled parts (Goal, Context, Steps, Rules, Result) stand out. */}
+            {state.result.refined.split("\n").map((line, i) => {
+              const label = /^(Goal|Context|Steps|Rules|Result):/.exec(line)
+              return label ? (
+                <text key={i}>
+                  <span fg={COLOR}>{label[0]}</span>
+                  <span fg={theme.text}>{line.slice(label[0].length)}</span>
+                </text>
+              ) : (
+                <text key={i} fg={line.trim() ? theme.text : undefined}>
+                  {line || " "}
+                </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)}

package/src/tui/shortcuts.tsx

@@ -0,0 +1,66 @@
+import { theme } from "./theme.ts"
+
+/** Every key the shell answers to, in one panel (? on an empty prompt); esc or ? closes it. */
+export const SHORTCUTS: { group: string; keys: [string, string][] }[] = [
+  {
+    group: "Prompt",
+    keys: [
+      ["enter", "send the request"],
+      ["shift+enter, ctrl+j", "new line"],
+      ["ctrl+r", "refine the request before it is sent"],
+      ["/  @", "commands; runs, files, and work items to reference"],
+      ["tab", "complete a suggestion, or the next model profile"],
+    ],
+  },
+  {
+    group: "Find and move",
+    keys: [
+      ["ctrl+p", "search: actions, commands, profiles, examples"],
+      ["shift+tab", "move between the chat and the plan, activity, and files panels"],
+      ["ctrl+o", "chat or details, on a narrow terminal"],
+      ["alt+1 to alt+4", "a start action, or a next step"],
+    ],
+  },
+  {
+    group: "Run",
+    keys: [
+      ["esc", "stop the request (asks first)"],
+      ["ctrl+c", "close ForgeQE (asks first; twice closes)"],
+      ["drag", "copy the selected text"],
+    ],
+  },
+]
+
+export function ShortcutsPanel(props: { width: number; wide: boolean; onClose: () => void }) {
+  const boxWidth = Math.min(84, props.width - 8)
+  const keyWidth = 22
+  return (
+    <box
+      position="absolute"
+      zIndex={100}
+      border
+      borderStyle="rounded"
+      borderColor={theme.accent}
+      title=" Keyboard shortcuts "
+      titleColor={theme.accent}
+      bottomTitle=" esc close "
+      bottomTitleAlignment="right"
+      onMouseDown={props.onClose}
+      style={{ top: 2, left: Math.floor((props.width - boxWidth) / 2), width: boxWidth, flexDirection: "column", backgroundColor: theme.panel, paddingLeft: 2, paddingRight: 2, paddingTop: 1 }}
+    >
+      {SHORTCUTS.map((g) => (
+        <box key={g.group} style={{ flexDirection: "column", marginBottom: 1, flexShrink: 0 }}>
+          <text fg={theme.muted}>{g.group}</text>
+          {g.keys
+            .filter(([k]) => props.wide || k !== "shift+tab")
+            .map(([k, what]) => (
+              <text key={k}>
+                <span fg={theme.text}>{`  ${k.padEnd(keyWidth)}`}</span>
+                <span fg={theme.muted}>{what}</span>
+              </text>
+            ))}
+        </box>
+      ))}
+    </box>
+  )
+}