@jitsusama/agentic-harness.core 0.1.0

package/dist/google/renderers/drive.js

@@ -0,0 +1,214 @@
+/**
+ * Drive file rendering to markdown.
+ */
+/**
+ * Render Drive file list as markdown.
+ */
+export function renderFileList(files, nextPageToken) {
+    if (files.length === 0) {
+        return "No files found.";
+    }
+    const lines = ["# Drive Files\n"];
+    for (const file of files) {
+        const icon = getMimeIcon(file.mimeType);
+        const size = file.size ? formatSize(file.size) : "";
+        const owner = file.owners && file.owners.length > 0 ? file.owners[0]?.displayName : "";
+        const sizeStr = size ? ` · ${size}` : "";
+        const ownerStr = owner ? ` · ${owner}` : "";
+        const modified = file.modifiedTime.slice(0, 10);
+        lines.push(`- ${icon} **${file.name}**${sizeStr}${ownerStr}`);
+        lines.push(`  Modified: ${modified} · \`${file.id}\``);
+        lines.push("");
+    }
+    if (nextPageToken) {
+        lines.push(`**Next page:** \`${nextPageToken}\``);
+    }
+    return lines.join("\n");
+}
+/**
+ * Render a Google Doc as markdown.
+ *
+ * When the document has multiple tabs, each tab is rendered
+ * under its own heading. Single-tab documents render flat
+ * (no extra heading) for a clean reading experience.
+ */
+export function renderDoc(file, content, comments) {
+    const lines = [];
+    lines.push(`# 📝 ${content.title}\n`);
+    lines.push(`Last modified: ${file.modifiedTime.slice(0, 10)}`);
+    if (file.owners && file.owners.length > 0) {
+        lines.push(`Owner: ${file.owners[0]?.displayName}`);
+    }
+    lines.push(`ID: \`${file.id}\``);
+    if (file.webViewLink) {
+        lines.push(`Link: ${file.webViewLink}`);
+    }
+    const tabs = content.tabs;
+    const multiTab = tabs.length > 1;
+    if (multiTab) {
+        lines.push(`Tabs: ${tabs.length}`);
+    }
+    lines.push("\n---\n");
+    if (multiTab) {
+        for (const tab of tabs) {
+            lines.push(renderTabHeading(tab));
+            lines.push(tab.body);
+            lines.push("");
+        }
+    }
+    else {
+        lines.push(content.body);
+    }
+    if (comments && comments.length > 0) {
+        lines.push("\n---\n");
+        lines.push(renderComments(comments));
+    }
+    return lines.join("\n");
+}
+/**
+ * Maximum heading depth for tab headings.
+ *
+ * Google Docs allows up to 3 nesting levels (nestingLevel 0–3).
+ * With the +2 offset that maps to heading levels 2–5 (`##`
+ * through `#####`), covering the full range the UI supports.
+ */
+const MAX_TAB_HEADING_LEVEL = 5;
+/**
+ * Render a tab section heading with its title and ID.
+ *
+ * Root tabs render as `##`, children as `###`, grandchildren
+ * as `####`, and the deepest subtabs as `#####`.
+ */
+function renderTabHeading(tab) {
+    const level = Math.min(tab.nestingLevel + 2, MAX_TAB_HEADING_LEVEL);
+    const hashes = "#".repeat(level);
+    const idSuffix = tab.id ? ` \`${tab.id}\`` : "";
+    return `${hashes} 📑 ${tab.title}${idSuffix}\n`;
+}
+/**
+ * Render a Google Sheet as markdown.
+ */
+export function renderSheet(file, content, comments) {
+    const lines = [];
+    lines.push(`# 📊 ${content.title}\n`);
+    lines.push(`Last modified: ${file.modifiedTime.slice(0, 10)}`);
+    if (file.owners && file.owners.length > 0) {
+        lines.push(`Owner: ${file.owners[0]?.displayName}`);
+    }
+    lines.push(`ID: \`${file.id}\``);
+    if (file.webViewLink) {
+        lines.push(`Link: ${file.webViewLink}`);
+    }
+    lines.push("");
+    for (const sheet of content.sheets) {
+        lines.push(`## ${sheet.name}\n`);
+        if (sheet.rows.length === 0) {
+            lines.push("_(empty sheet)_\n");
+            continue;
+        }
+        // We render the sheet as a markdown table.
+        const header = sheet.rows[0] || [];
+        const dataRows = sheet.rows.slice(1);
+        lines.push(`| ${header.join(" | ")} |`);
+        lines.push(`| ${header.map(() => "---").join(" | ")} |`);
+        for (const row of dataRows) {
+            // We pad the row to match the header length.
+            const paddedRow = [...row];
+            while (paddedRow.length < header.length) {
+                paddedRow.push("");
+            }
+            lines.push(`| ${paddedRow.slice(0, header.length).join(" | ")} |`);
+        }
+        lines.push("");
+    }
+    if (comments && comments.length > 0) {
+        lines.push("---\n");
+        lines.push(renderComments(comments));
+    }
+    return lines.join("\n");
+}
+/**
+ * Render Google Slides as markdown.
+ */
+export function renderSlides(file, content, comments) {
+    const lines = [];
+    lines.push(`# 📽️ ${content.title}\n`);
+    lines.push(`Last modified: ${file.modifiedTime.slice(0, 10)}`);
+    if (file.owners && file.owners.length > 0) {
+        lines.push(`Owner: ${file.owners[0]?.displayName}`);
+    }
+    lines.push(`ID: \`${file.id}\``);
+    if (file.webViewLink) {
+        lines.push(`Link: ${file.webViewLink}`);
+    }
+    lines.push("");
+    for (const slide of content.slides) {
+        lines.push(`## Slide ${slide.number}\n`);
+        lines.push(slide.text || "_(no text)_");
+        lines.push("");
+    }
+    if (comments && comments.length > 0) {
+        lines.push("---\n");
+        lines.push(renderComments(comments));
+    }
+    return lines.join("\n");
+}
+/**
+ * Render document comments.
+ */
+export function renderComments(comments) {
+    if (comments.length === 0) {
+        return "";
+    }
+    const unresolved = comments.filter((c) => !c.resolved).length;
+    const resolved = comments.length - unresolved;
+    const lines = [];
+    lines.push(`## Comments (${unresolved} unresolved${resolved > 0 ? `, ${resolved} resolved` : ""})\n`);
+    for (const comment of comments) {
+        const status = comment.resolved ? "✓ Resolved" : "Open";
+        const author = comment.author.displayName;
+        const date = comment.createdTime.slice(0, 10);
+        lines.push(`**${author}** · ${date} · ${status}`);
+        lines.push(`> ${comment.content}\n`);
+        if (comment.replies && comment.replies.length > 0) {
+            for (const reply of comment.replies) {
+                const replyAuthor = reply.author.displayName;
+                const replyDate = reply.createdTime.slice(0, 10);
+                lines.push(`  **${replyAuthor}** · ${replyDate}`);
+                lines.push(`  > ${reply.content}\n`);
+            }
+        }
+    }
+    return lines.join("\n");
+}
+function getMimeIcon(mimeType) {
+    const icons = {
+        "application/vnd.google-apps.folder": "📁",
+        "application/vnd.google-apps.document": "📝",
+        "application/vnd.google-apps.spreadsheet": "📊",
+        "application/vnd.google-apps.presentation": "📽️",
+        "application/vnd.google-apps.form": "📋",
+        "application/pdf": "📄",
+    };
+    for (const [prefix, icon] of Object.entries(icons)) {
+        if (mimeType.startsWith(prefix)) {
+            return icon;
+        }
+    }
+    if (mimeType.startsWith("image/"))
+        return "🖼️";
+    if (mimeType.startsWith("video/"))
+        return "🎬";
+    if (mimeType.startsWith("audio/"))
+        return "🎵";
+    return "📎";
+}
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}

package/dist/google/renderers/email.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Email rendering to markdown.
+ */
+import type { EmailMessage, EmailMessageFull } from "../types.js";
+/**
+ * Render email list as markdown.
+ */
+export declare function renderEmailList(messages: EmailMessage[], nextPageToken?: string): string;
+/**
+ * Render a single email as markdown.
+ */
+export declare function renderEmail(msg: EmailMessageFull): string;
+/**
+ * Render email thread as markdown.
+ */
+export declare function renderThread(messages: EmailMessageFull[]): string;

package/dist/google/renderers/email.js

@@ -0,0 +1,130 @@
+/**
+ * Email rendering to markdown.
+ */
+import { count } from "../../ui/count.js";
+/**
+ * Render email list as markdown.
+ */
+export function renderEmailList(messages, nextPageToken) {
+    if (messages.length === 0) {
+        return "No emails found.";
+    }
+    const lines = ["# Emails\n"];
+    for (const msg of messages) {
+        const fromName = msg.from.name || msg.from.email;
+        const subject = msg.subject;
+        const date = formatDate(msg.date);
+        const labels = filterInterestingLabels(msg.labels);
+        const labelTags = labels.length > 0 ? ` ${labels.map((l) => `\`${l}\``).join(" ")}` : "";
+        const attachmentIcon = msg.hasAttachments ? " 📎" : "";
+        lines.push(`- **${subject}**${labelTags}${attachmentIcon}`);
+        lines.push(`  ${fromName} · ${date} · \`${msg.id}\``);
+        if (msg.snippet) {
+            lines.push(`  ${msg.snippet.slice(0, 120)}${msg.snippet.length > 120 ? "..." : ""}`);
+        }
+        lines.push("");
+    }
+    if (nextPageToken) {
+        lines.push(`**Next page:** \`${nextPageToken}\``);
+    }
+    return lines.join("\n");
+}
+/**
+ * Render a single email as markdown.
+ */
+export function renderEmail(msg) {
+    const lines = [];
+    lines.push(`# ${msg.subject}\n`);
+    // Headers
+    lines.push(`- **From:** ${formatEmailAddress(msg.from)}`);
+    lines.push(`- **To:** ${msg.to.map(formatEmailAddress).join(", ")}`);
+    if (msg.cc && msg.cc.length > 0) {
+        lines.push(`- **Cc:** ${msg.cc.map(formatEmailAddress).join(", ")}`);
+    }
+    lines.push(`- **Date:** ${formatDate(msg.date)}`);
+    lines.push(`- **ID:** \`${msg.id}\``);
+    // Attachments
+    if (msg.attachments.length > 0) {
+        lines.push("\n## Attachments\n");
+        for (const att of msg.attachments) {
+            const size = formatSize(att.size);
+            lines.push(`- ${att.filename} (${size})`);
+        }
+    }
+    // Body
+    lines.push("\n---\n");
+    lines.push(msg.body);
+    return lines.join("\n");
+}
+/**
+ * Render email thread as markdown.
+ */
+export function renderThread(messages) {
+    if (messages.length === 0) {
+        return "No messages in thread.";
+    }
+    const lines = [];
+    const subject = messages[0]?.subject || "Thread";
+    lines.push(`# ${subject}`);
+    lines.push(`\n_Thread with ${count(messages.length, "message")}_\n`);
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (!msg)
+            continue;
+        lines.push(`## Message ${i + 1}`);
+        lines.push(`**From:** ${formatEmailAddress(msg.from)}`);
+        lines.push(`**Date:** ${formatDate(msg.date)}`);
+        lines.push(`**ID:** \`${msg.id}\`\n`);
+        if (msg.attachments.length > 0) {
+            lines.push("**Attachments:**");
+            for (const att of msg.attachments) {
+                lines.push(`- ${att.filename} (${formatSize(att.size)})`);
+            }
+            lines.push("");
+        }
+        lines.push(msg.body);
+        lines.push("\n---\n");
+    }
+    return lines.join("\n");
+}
+function formatEmailAddress(addr) {
+    if (addr.name) {
+        return `${addr.name} <${addr.email}>`;
+    }
+    return addr.email;
+}
+function formatDate(dateStr) {
+    try {
+        const date = new Date(dateStr);
+        return date.toLocaleString("en-US", {
+            year: "numeric",
+            month: "short",
+            day: "numeric",
+            hour: "2-digit",
+            minute: "2-digit",
+        });
+    }
+    catch (_error) {
+        // Date parsing failed, so we return a truncated raw string as a fallback.
+        return dateStr.slice(0, 16);
+    }
+}
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function filterInterestingLabels(labels) {
+    const skipLabels = new Set([
+        "INBOX",
+        "UNREAD",
+        "CATEGORY_PRIMARY",
+        "CATEGORY_SOCIAL",
+        "CATEGORY_UPDATES",
+        "CATEGORY_PROMOTIONS",
+        "CATEGORY_FORUMS",
+    ]);
+    return labels.filter((l) => !skipLabels.has(l));
+}

package/dist/google/renderers/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Google Workspace content renderers: markdown formatting
+ * for calendar events, drive files, docs, sheets, slides
+ * and email messages.
+ */
+export { renderEvent, renderEventList, renderFreeBusy } from "./calendar.js";
+export { renderComments, renderDoc, renderFileList, renderSheet, renderSlides, } from "./drive.js";
+export { renderEmail, renderEmailList, renderThread, } from "./email.js";

package/dist/google/renderers/index.js

@@ -0,0 +1,8 @@
+/**
+ * Google Workspace content renderers: markdown formatting
+ * for calendar events, drive files, docs, sheets, slides
+ * and email messages.
+ */
+export { renderEvent, renderEventList, renderFreeBusy } from "./calendar.js";
+export { renderComments, renderDoc, renderFileList, renderSheet, renderSlides, } from "./drive.js";
+export { renderEmail, renderEmailList, renderThread, } from "./email.js";

package/dist/google/types.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Shared types used across the Google Workspace extension.
+ */
+/** Parameters passed to router actions. */
+export type ActionParams = Record<string, unknown>;
+/** Extract a string parameter, returning undefined if absent or wrong type. */
+export declare function getStringParam(params: ActionParams, key: string): string | undefined;
+/** Extract a number parameter, returning undefined if absent or wrong type. */
+export declare function getNumberParam(params: ActionParams, key: string): number | undefined;
+/** Extract a boolean parameter, returning undefined if absent or wrong type. */
+export declare function getBooleanParam(params: ActionParams, key: string): boolean | undefined;
+/** Extract a string array parameter, returning undefined if absent or wrong type. */
+export declare function getStringArrayParam(params: ActionParams, key: string): string[] | undefined;
+/** Result of a tool execution. */
+export interface ToolResult {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    details?: unknown;
+}
+/** Google account configuration. */
+export interface GoogleAccount {
+    name: string;
+    email?: string;
+    isDefault: boolean;
+}
+/** Stored credentials for an account. */
+export interface StoredCredentials {
+    access_token: string;
+    refresh_token: string;
+    expiry_date: number;
+    token_type: string;
+    scope: string;
+}
+/** Gmail message metadata. */
+export interface EmailMessage {
+    id: string;
+    threadId: string;
+    subject: string;
+    from: {
+        name: string;
+        email: string;
+    };
+    to: Array<{
+        name: string;
+        email: string;
+    }>;
+    cc?: Array<{
+        name: string;
+        email: string;
+    }>;
+    date: string;
+    snippet: string;
+    labels: string[];
+    hasAttachments: boolean;
+}
+/** Gmail message with full content. */
+export interface EmailMessageFull extends EmailMessage {
+    body: string;
+    attachments: Array<{
+        filename: string;
+        mimeType: string;
+        size: number;
+    }>;
+}
+/** Calendar event. */
+export interface CalendarEvent {
+    id: string;
+    summary: string;
+    description?: string;
+    location?: string;
+    start: string;
+    end: string;
+    attendees?: Array<{
+        email: string;
+        displayName?: string;
+        responseStatus?: "accepted" | "declined" | "tentative" | "needsAction";
+        self?: boolean;
+    }>;
+    conferenceData?: {
+        entryPoints?: Array<{
+            entryPointType: string;
+            uri: string;
+            label?: string;
+        }>;
+    };
+    status?: string;
+    htmlLink?: string;
+}
+/** A time range when someone is busy. */
+export interface BusyPeriod {
+    start: string;
+    end: string;
+}
+/** Free/busy result for a single calendar. */
+export interface CalendarFreeBusy {
+    email: string;
+    busy: BusyPeriod[];
+    /** True when this entry represents the authenticated user. */
+    self?: boolean;
+    /** Per-calendar errors (e.g. "notFound" for invalid emails). */
+    errors?: string[];
+}
+/** Result of a free/busy query across multiple calendars. */
+export interface FreeBusyResult {
+    timeMin: string;
+    timeMax: string;
+    calendars: CalendarFreeBusy[];
+}
+/** Drive file metadata. */
+export interface DriveFile {
+    id: string;
+    name: string;
+    mimeType: string;
+    size?: number;
+    modifiedTime: string;
+    owners?: Array<{
+        displayName: string;
+        emailAddress: string;
+    }>;
+    webViewLink?: string;
+    iconLink?: string;
+}
+/** Document comment. */
+export interface DocumentComment {
+    id: string;
+    content: string;
+    author: {
+        displayName: string;
+        emailAddress?: string;
+    };
+    createdTime: string;
+    resolved: boolean;
+    replies?: Array<{
+        content: string;
+        author: {
+            displayName: string;
+            emailAddress?: string;
+        };
+        createdTime: string;
+    }>;
+}

package/dist/google/types.js

@@ -0,0 +1,27 @@
+/**
+ * Shared types used across the Google Workspace extension.
+ */
+/** Extract a string parameter, returning undefined if absent or wrong type. */
+export function getStringParam(params, key) {
+    const value = params[key];
+    return typeof value === "string" ? value : undefined;
+}
+/** Extract a number parameter, returning undefined if absent or wrong type. */
+export function getNumberParam(params, key) {
+    const value = params[key];
+    return typeof value === "number" ? value : undefined;
+}
+/** Extract a boolean parameter, returning undefined if absent or wrong type. */
+export function getBooleanParam(params, key) {
+    const value = params[key];
+    return typeof value === "boolean" ? value : undefined;
+}
+/** Extract a string array parameter, returning undefined if absent or wrong type. */
+export function getStringArrayParam(params, key) {
+    const value = params[key];
+    if (!Array.isArray(value))
+        return undefined;
+    return value.every((v) => typeof v === "string")
+        ? value
+        : undefined;
+}

package/dist/governance/distill.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Distillation helpers for correction capture.
+ *
+ * Turning a session into behavioural rules has three pure parts:
+ * condensing the transcript into a compact prompt, the system
+ * prompt that asks a model to distill rules, and parsing the
+ * model's reply back into a clean list. The live model call sits
+ * between them in the extension; these parts are testable on
+ * their own.
+ */
+/** One turn of a conversation, reduced to role and text. */
+export interface Turn {
+    readonly role: "user" | "assistant";
+    readonly text: string;
+}
+/**
+ * Condense turns into a compact transcript string, keeping the
+ * most recent turns when the whole exceeds `maxChars`. The tail
+ * is what matters: corrections accumulate as the session goes on.
+ */
+export declare function condenseTranscript(turns: Turn[], maxChars?: number): string;
+/** The system prompt that asks a model to distill rules. */
+export declare function distillSystemPrompt(): string;
+/** Build the user prompt for a distillation, with optional focus. */
+export declare function distillUserPrompt(transcript: string, focus?: string): string;
+/**
+ * Parse a model reply into a clean rule list. Accepts a JSON
+ * array anywhere in the reply, and falls back to markdown bullet
+ * or numbered lines when the model wrapped the array in prose.
+ */
+export declare function parseRules(reply: string): string[];

package/dist/governance/distill.js

@@ -0,0 +1,78 @@
+/**
+ * Distillation helpers for correction capture.
+ *
+ * Turning a session into behavioural rules has three pure parts:
+ * condensing the transcript into a compact prompt, the system
+ * prompt that asks a model to distill rules, and parsing the
+ * model's reply back into a clean list. The live model call sits
+ * between them in the extension; these parts are testable on
+ * their own.
+ */
+import { firstJsonArray } from "../internal/json-array.js";
+/** Default cap on the condensed transcript, in characters. */
+const DEFAULT_MAX_CHARS = 6000;
+/**
+ * Condense turns into a compact transcript string, keeping the
+ * most recent turns when the whole exceeds `maxChars`. The tail
+ * is what matters: corrections accumulate as the session goes on.
+ */
+export function condenseTranscript(turns, maxChars = DEFAULT_MAX_CHARS) {
+    const lines = turns
+        .filter((t) => t.text.trim().length > 0)
+        .map((t) => `${t.role === "user" ? "USER" : "ASSISTANT"}: ${t.text.trim()}`);
+    let transcript = lines.join("\n\n");
+    while (transcript.length > maxChars && lines.length > 1) {
+        lines.shift();
+        transcript = lines.join("\n\n");
+    }
+    if (transcript.length > maxChars) {
+        transcript = transcript.slice(transcript.length - maxChars);
+    }
+    return transcript;
+}
+/** The system prompt that asks a model to distill rules. */
+export function distillSystemPrompt() {
+    return [
+        "You distill behavioural rules from a coding session.",
+        "Read the transcript and find where the user corrected, steered",
+        "or pushed back on the assistant. For each distinct lesson, write",
+        "one short imperative rule the assistant should follow in future",
+        "sessions. Rules are behavioural, not about a single task.",
+        "",
+        "Return only a JSON array of strings, each a single rule. No prose",
+        "around it. Return an empty array when the session holds no lesson",
+        "worth keeping. Aim for one to five rules; never invent a rule the",
+        "transcript does not support.",
+    ].join("\n");
+}
+/** Build the user prompt for a distillation, with optional focus. */
+export function distillUserPrompt(transcript, focus) {
+    const head = focus ? `Focus on this when distilling: ${focus}\n\n` : "";
+    return `${head}Transcript:\n\n${transcript}`;
+}
+/**
+ * Parse a model reply into a clean rule list. Accepts a JSON
+ * array anywhere in the reply, and falls back to markdown bullet
+ * or numbered lines when the model wrapped the array in prose.
+ */
+export function parseRules(reply) {
+    const array = firstJsonArray(reply);
+    if (array) {
+        try {
+            const parsed = JSON.parse(array);
+            if (Array.isArray(parsed)) {
+                return parsed
+                    .filter((r) => typeof r === "string")
+                    .map((r) => r.trim())
+                    .filter((r) => r.length > 0);
+            }
+        }
+        catch {
+            // Not valid JSON; fall through to line parsing.
+        }
+    }
+    return reply
+        .split("\n")
+        .map((line) => line.replace(/^\s*(?:[-*+]|\d+[.)])\s+/, "").trim())
+        .filter((line) => line.length > 0 && !line.startsWith("["));
+}

package/dist/governance/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Governance: the captured-rule store and its prompt rendering.
+ *
+ * Correction capture files behavioural rules here; the prompt
+ * coordinator injects them every turn and the advisor reviews
+ * turns against them. One store, two readers.
+ */
+export { condenseTranscript, distillSystemPrompt, distillUserPrompt, parseRules, type Turn, } from "./distill.js";
+export { renderRulesBlock } from "./render.js";
+export { type NewRule, openRuleStore, type RuleStore } from "./store.js";
+export type { GovernanceRule } from "./types.js";

package/dist/governance/index.js

@@ -0,0 +1,10 @@
+/**
+ * Governance: the captured-rule store and its prompt rendering.
+ *
+ * Correction capture files behavioural rules here; the prompt
+ * coordinator injects them every turn and the advisor reviews
+ * turns against them. One store, two readers.
+ */
+export { condenseTranscript, distillSystemPrompt, distillUserPrompt, parseRules, } from "./distill.js";
+export { renderRulesBlock } from "./render.js";
+export { openRuleStore } from "./store.js";