@jitsusama/agentic-harness.core 0.1.0

package/dist/google/apis/calendar.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Google Calendar API client.
+ */
+import type { OAuth2Client } from "google-auth-library";
+import type { CalendarEvent, FreeBusyResult } from "../types.js";
+/**
+ * List calendar events in a date range.
+ */
+export declare function listEvents(auth: OAuth2Client, options?: {
+    start?: string;
+    end?: string;
+    calendarId?: string;
+    maxResults?: number;
+}): Promise<CalendarEvent[]>;
+/**
+ * Get a single calendar event.
+ */
+export declare function getEvent(auth: OAuth2Client, eventId: string, calendarId?: string): Promise<CalendarEvent>;
+/**
+ * Create a calendar event.
+ */
+export declare function createEvent(auth: OAuth2Client, options: {
+    summary: string;
+    start: string;
+    end: string;
+    description?: string;
+    location?: string;
+    attendees?: string[];
+    calendarId?: string;
+}): Promise<CalendarEvent>;
+/**
+ * Update a calendar event.
+ */
+export declare function updateEvent(auth: OAuth2Client, eventId: string, options: {
+    summary?: string;
+    start?: string;
+    end?: string;
+    description?: string;
+    location?: string;
+    attendees?: string[];
+    calendarId?: string;
+}): Promise<CalendarEvent>;
+/**
+ * Delete a calendar event.
+ */
+export declare function deleteEvent(auth: OAuth2Client, eventId: string, calendarId?: string): Promise<void>;
+/**
+ * Query free/busy information for multiple calendars.
+ *
+ * Automatically includes the authenticated user's calendar
+ * alongside the provided attendee emails so the result
+ * reflects everyone's availability. Deduplicates if the
+ * user's email is already in the list.
+ */
+export declare function queryFreeBusy(auth: OAuth2Client, options: {
+    emails: string[];
+    timeMin: string;
+    timeMax: string;
+    timeZone?: string;
+}): Promise<FreeBusyResult>;
+/**
+ * Respond to a calendar event invitation.
+ */
+export declare function respondToEvent(auth: OAuth2Client, eventId: string, response: "accepted" | "declined" | "tentative", calendarId?: string): Promise<CalendarEvent>;

package/dist/google/apis/calendar.js

@@ -0,0 +1,297 @@
+/**
+ * Google Calendar API client.
+ */
+import { google } from "googleapis";
+/**
+ * List calendar events in a date range.
+ */
+export async function listEvents(auth, options = {}) {
+    const calendar = google.calendar({ version: "v3", auth });
+    // We parse the date strings.
+    const timeMin = parseDate(options.start || "today");
+    const timeMax = parseDate(options.end);
+    const response = await calendar.events.list({
+        calendarId: options.calendarId || "primary",
+        timeMin: timeMin.toISOString(),
+        timeMax: timeMax?.toISOString(),
+        maxResults: options.maxResults || 100,
+        singleEvents: true,
+        orderBy: "startTime",
+    });
+    const events = [];
+    for (const event of response.data.items || []) {
+        events.push(convertEvent(event));
+    }
+    return events;
+}
+/**
+ * Get a single calendar event.
+ */
+export async function getEvent(auth, eventId, calendarId = "primary") {
+    const calendar = google.calendar({ version: "v3", auth });
+    const response = await calendar.events.get({
+        calendarId,
+        eventId,
+    });
+    return convertEvent(response.data);
+}
+function parseDate(dateStr) {
+    if (!dateStr) {
+        // We default to the end of today.
+        const date = new Date();
+        date.setHours(23, 59, 59, 999);
+        return date;
+    }
+    if (dateStr === "today") {
+        const date = new Date();
+        date.setHours(0, 0, 0, 0);
+        return date;
+    }
+    if (dateStr === "tomorrow") {
+        const date = new Date();
+        date.setDate(date.getDate() + 1);
+        date.setHours(0, 0, 0, 0);
+        return date;
+    }
+    // We try to parse it as an ISO date.
+    try {
+        return new Date(dateStr);
+    }
+    catch (_error) {
+        // The Date constructor threw, so we re-throw with context.
+        throw new Error(`Invalid date: ${dateStr}`);
+    }
+}
+function convertEvent(event) {
+    const e = event;
+    const startTime = e.start?.dateTime || e.start?.date || "";
+    const endTime = e.end?.dateTime || e.end?.date || "";
+    return {
+        id: e.id || "",
+        summary: e.summary || "(no title)",
+        description: e.description,
+        location: e.location,
+        start: startTime,
+        end: endTime,
+        attendees: convertAttendees(e.attendees),
+        conferenceData: convertConferenceData(e.conferenceData),
+        status: e.status,
+        htmlLink: e.htmlLink,
+    };
+}
+function convertAttendees(attendees) {
+    if (!Array.isArray(attendees))
+        return [];
+    return attendees.map((a) => {
+        const attendee = a;
+        return {
+            email: attendee.email || "",
+            displayName: attendee.displayName,
+            responseStatus: attendee.responseStatus,
+            self: attendee.self,
+        };
+    });
+}
+function convertConferenceData(data) {
+    if (!data || typeof data !== "object")
+        return undefined;
+    const conf = data;
+    if (!conf.entryPoints)
+        return undefined;
+    return {
+        entryPoints: conf.entryPoints.map((ep) => {
+            const entry = ep;
+            return {
+                entryPointType: entry.entryPointType || "",
+                uri: entry.uri || "",
+                label: entry.label,
+            };
+        }),
+    };
+}
+/**
+ * Create a calendar event.
+ */
+export async function createEvent(auth, options) {
+    const calendar = google.calendar({ version: "v3", auth });
+    const event = {
+        summary: options.summary,
+        description: options.description,
+        location: options.location,
+        start: {
+            dateTime: options.start,
+            timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        },
+        end: {
+            dateTime: options.end,
+            timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        },
+        attendees: options.attendees?.map((email) => ({ email })),
+    };
+    try {
+        const response = await calendar.events.insert({
+            calendarId: options.calendarId || "primary",
+            requestBody: event,
+            sendUpdates: "all", // Send invites to attendees
+        });
+        return convertEvent(response.data);
+    }
+    catch (error) {
+        // We enhance the error message with details.
+        if (error && typeof error === "object" && "message" in error) {
+            const apiError = error;
+            const details = apiError.errors
+                ? JSON.stringify(apiError.errors, null, 2)
+                : "";
+            throw new Error(`Calendar API error: ${apiError.message}\n${details}\n\n` +
+                `Event data: ${JSON.stringify(event, null, 2)}`);
+        }
+        throw error;
+    }
+}
+/**
+ * Update a calendar event.
+ */
+export async function updateEvent(auth, eventId, options) {
+    const calendar = google.calendar({ version: "v3", auth });
+    // We get the existing event first.
+    const existing = await calendar.events.get({
+        calendarId: options.calendarId || "primary",
+        eventId,
+    });
+    // We merge the updates with the existing data.
+    const event = {
+        ...existing.data,
+        summary: options.summary ?? existing.data.summary,
+        description: options.description ?? existing.data.description,
+        location: options.location ?? existing.data.location,
+        start: options.start
+            ? {
+                dateTime: options.start,
+                timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+            }
+            : existing.data.start,
+        end: options.end
+            ? {
+                dateTime: options.end,
+                timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+            }
+            : existing.data.end,
+        attendees: options.attendees
+            ? options.attendees.map((email) => ({ email }))
+            : existing.data.attendees,
+    };
+    const response = await calendar.events.update({
+        calendarId: options.calendarId || "primary",
+        eventId,
+        requestBody: event,
+        sendUpdates: "all",
+    });
+    return convertEvent(response.data);
+}
+/**
+ * Delete a calendar event.
+ */
+export async function deleteEvent(auth, eventId, calendarId = "primary") {
+    const calendar = google.calendar({ version: "v3", auth });
+    await calendar.events.delete({
+        calendarId,
+        eventId,
+        sendUpdates: "all", // Notify attendees
+    });
+}
+/**
+ * Query free/busy information for multiple calendars.
+ *
+ * Automatically includes the authenticated user's calendar
+ * alongside the provided attendee emails so the result
+ * reflects everyone's availability. Deduplicates if the
+ * user's email is already in the list.
+ */
+export async function queryFreeBusy(auth, options) {
+    const calendar = google.calendar({ version: "v3", auth });
+    const userEmail = await resolveUserEmail(auth);
+    // We build the items list, always including the user's
+    // calendar and deduplicating if their email was already
+    // passed as an attendee.
+    const seen = new Set();
+    const items = [{ id: "primary" }];
+    if (userEmail)
+        seen.add(userEmail.toLowerCase());
+    for (const email of options.emails) {
+        const lower = email.toLowerCase();
+        if (!seen.has(lower)) {
+            seen.add(lower);
+            items.push({ id: email });
+        }
+    }
+    const response = await calendar.freebusy.query({
+        requestBody: {
+            timeMin: new Date(options.timeMin).toISOString(),
+            timeMax: new Date(options.timeMax).toISOString(),
+            timeZone: options.timeZone ?? Intl.DateTimeFormat().resolvedOptions().timeZone,
+            items,
+        },
+    });
+    const rawCalendars = response.data.calendars ?? {};
+    const calendars = [];
+    for (const [id, data] of Object.entries(rawCalendars)) {
+        const busy = (data.busy ?? []).map((period) => ({
+            start: period.start ?? "",
+            end: period.end ?? "",
+        }));
+        const errors = (data.errors ?? []).map((e) => e.reason ?? e.domain ?? "unknown");
+        const isSelf = id === "primary" ||
+            (userEmail !== undefined && id.toLowerCase() === userEmail.toLowerCase());
+        calendars.push({
+            email: isSelf ? (userEmail ?? "you") : id,
+            busy,
+            self: isSelf || undefined,
+            errors: errors.length > 0 ? errors : undefined,
+        });
+    }
+    return {
+        timeMin: response.data.timeMin ?? options.timeMin,
+        timeMax: response.data.timeMax ?? options.timeMax,
+        calendars,
+    };
+}
+/** Resolve the authenticated user's email from their OAuth token. */
+async function resolveUserEmail(auth) {
+    try {
+        const tokenInfo = await auth.getTokenInfo(auth.credentials.access_token || "");
+        return tokenInfo.email;
+    }
+    catch {
+        // Token info fetch is non-critical; we proceed without it.
+        return undefined;
+    }
+}
+/**
+ * Respond to a calendar event invitation.
+ */
+export async function respondToEvent(auth, eventId, response, calendarId = "primary") {
+    const calendar = google.calendar({ version: "v3", auth });
+    // We get the existing event.
+    const existing = await calendar.events.get({
+        calendarId,
+        eventId,
+    });
+    // We find our attendance entry and update the response.
+    const attendees = existing.data.attendees || [];
+    for (const attendee of attendees) {
+        if (attendee.self) {
+            attendee.responseStatus = response;
+        }
+    }
+    const updated = await calendar.events.update({
+        calendarId,
+        eventId,
+        requestBody: {
+            ...existing.data,
+            attendees,
+        },
+        sendUpdates: "all",
+    });
+    return convertEvent(updated.data);
+}

package/dist/google/apis/docs.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Google Docs API client.
+ */
+import type { OAuth2Client } from "google-auth-library";
+import type { DocumentComment } from "../types.js";
+/** A single tab within a Google Doc. */
+export interface DocTab {
+    id: string;
+    title: string;
+    body: string;
+    /** Nesting depth: 0 for root tabs, 1 for children, 2 for grandchildren. */
+    nestingLevel: number;
+}
+/** Extracted text content from a Google Doc. */
+export interface DocContent {
+    title: string;
+    /** Combined body text from all tabs (for backward compatibility). */
+    body: string;
+    /** Individual tabs with their own title and content. */
+    tabs: DocTab[];
+}
+/**
+ * Get document content, including all tabs.
+ */
+export declare function getDocContent(auth: OAuth2Client, documentId: string): Promise<DocContent>;
+/**
+ * Get comments on a document.
+ */
+export declare function getDocComments(auth: OAuth2Client, documentId: string, filter?: "all" | "resolved" | "unresolved"): Promise<DocumentComment[]>;

package/dist/google/apis/docs.js

@@ -0,0 +1,154 @@
+/**
+ * Google Docs API client.
+ */
+import { google } from "googleapis";
+/**
+ * Get document content, including all tabs.
+ */
+export async function getDocContent(auth, documentId) {
+    const docs = google.docs({ version: "v1", auth });
+    // `includeTabsContent` was missing from the googleapis v140 types
+    // and is present as of v173, so the cast that used to paper over
+    // it is gone. It was worse than unnecessary: `get` is overloaded,
+    // and Parameters<...>[0] selected the overload whose first
+    // argument is a response callback, which made this call resolve to
+    // void and every read of `doc.data` below an error.
+    const doc = await docs.documents.get({
+        documentId,
+        includeTabsContent: true,
+    });
+    const title = doc.data.title || "Untitled";
+    const rawTabs = doc.data.tabs;
+    if (rawTabs && rawTabs.length > 0) {
+        const multiTab = rawTabs.length > 1 || hasChildTabs(rawTabs);
+        const tabs = flattenTabs(rawTabs, multiTab);
+        const body = tabs.map((t) => t.body).join("\n\n");
+        return { title, body, tabs };
+    }
+    // When includeTabsContent is true the API empties
+    // document.body, so we can't read it as a fallback.
+    // Re-fetch without the flag to get first-tab content.
+    const fallback = await docs.documents.get({ documentId });
+    const body = extractBodyContent(fallback.data.body);
+    return {
+        title,
+        body,
+        tabs: [{ id: "", title: "Tab 1", body, nestingLevel: 0 }],
+    };
+}
+/**
+ * Get comments on a document.
+ */
+export async function getDocComments(auth, documentId, filter) {
+    const drive = google.drive({ version: "v3", auth });
+    const response = await drive.comments.list({
+        fileId: documentId,
+        fields: "comments(id,content,author,createdTime,resolved,replies,quotedFileContent)",
+        includeDeleted: false,
+    });
+    let comments = (response.data.comments || []).map(convertComment);
+    // We filter by resolved status.
+    if (filter === "resolved") {
+        comments = comments.filter((c) => c.resolved);
+    }
+    else if (filter === "unresolved") {
+        comments = comments.filter((c) => !c.resolved);
+    }
+    return comments;
+}
+/** Check whether any tab in the list has children. */
+function hasChildTabs(tabs) {
+    return tabs.some((t) => t.childTabs && t.childTabs.length > 0);
+}
+/**
+ * Recursively flatten the tab tree into an ordered list
+ * matching the UI's top-down tab order.
+ */
+function flattenTabs(tabs, multiTab) {
+    const result = [];
+    for (const tab of tabs) {
+        const id = tab.tabProperties?.tabId || "";
+        const title = tab.tabProperties?.title || "Untitled tab";
+        const nestingLevel = tab.tabProperties?.nestingLevel ?? 0;
+        // In multi-tab documents, shift body headings so they
+        // nest below the tab's own heading. The tab heading is
+        // at level nestingLevel + 2, so body headings start one
+        // level deeper. Single-tab docs render flat (no tab
+        // heading), so body headings stay at their native level.
+        const headingOffset = multiTab ? nestingLevel + 2 : 0;
+        const body = extractBodyContent(tab.documentTab?.body, headingOffset);
+        result.push({ id, title, body, nestingLevel });
+        if (tab.childTabs && tab.childTabs.length > 0) {
+            result.push(...flattenTabs(tab.childTabs, multiTab));
+        }
+    }
+    return result;
+}
+/** Markdown supports heading levels 1–6. */
+const MAX_HEADING_LEVEL = 6;
+/**
+ * Extract text content from a Docs API body object.
+ *
+ * When `headingOffset` is non-zero, document headings are
+ * shifted so they nest below a parent tab heading. A
+ * HEADING_1 with offset 2 becomes `###` (level 3). Levels
+ * that would exceed 6 are clamped at `######`.
+ */
+function extractBodyContent(body, headingOffset = 0) {
+    if (!body?.content)
+        return "";
+    const lines = [];
+    for (const element of body.content) {
+        const el = element;
+        if (!el.paragraph)
+            continue;
+        const style = el.paragraph.paragraphStyle?.namedStyleType || "";
+        let text = "";
+        for (const elem of el.paragraph.elements || []) {
+            const e = elem;
+            if (e.textRun?.content) {
+                text += e.textRun.content;
+            }
+        }
+        text = text.replace(/\n+$/, ""); // Trim trailing newlines
+        if (!text) {
+            lines.push("");
+            continue;
+        }
+        // Headings get converted to markdown heading syntax.
+        if (style.startsWith("HEADING_")) {
+            const docLevel = Number.parseInt(style.replace("HEADING_", ""), 10);
+            const level = Math.min(docLevel + headingOffset, MAX_HEADING_LEVEL);
+            lines.push(`${"#".repeat(level)} ${text}`);
+            lines.push("");
+        }
+        else {
+            lines.push(text);
+        }
+    }
+    return lines.join("\n");
+}
+function convertComment(comment) {
+    const c = comment;
+    return {
+        id: c.id || "",
+        content: c.content || "",
+        author: {
+            displayName: c.author?.displayName || "",
+            emailAddress: c.author?.emailAddress,
+        },
+        createdTime: c.createdTime || "",
+        resolved: c.resolved || false,
+        replies: (c.replies || []).map((r) => {
+            const reply = r;
+            return {
+                content: reply.content || "",
+                author: {
+                    displayName: reply.author?.displayName || "",
+                    emailAddress: reply.author?.emailAddress,
+                },
+                createdTime: reply.createdTime || "",
+            };
+        }),
+    };
+}

package/dist/google/apis/drive.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Google Drive API client.
+ */
+import type { OAuth2Client } from "google-auth-library";
+import type { DriveFile } from "../types.js";
+/**
+ * List Drive files with optional filtering.
+ */
+export declare function listFiles(auth: OAuth2Client, options?: {
+    query?: string;
+    folderId?: string;
+    type?: "doc" | "sheet" | "slides" | "folder" | "pdf";
+    owner?: "me" | string;
+    shared?: boolean;
+    sharedDriveId?: string;
+    orderBy?: "modifiedTime" | "name" | "relevance";
+    modifiedAfter?: string;
+    modifiedBefore?: string;
+    limit?: number;
+    pageToken?: string;
+}): Promise<{
+    files: DriveFile[];
+    nextPageToken?: string;
+}>;
+/**
+ * Get file metadata.
+ */
+export declare function getFileMetadata(auth: OAuth2Client, fileId: string): Promise<DriveFile>;
+/**
+ * List shared drives accessible to the user.
+ */
+export declare function listSharedDrives(auth: OAuth2Client): Promise<Array<{
+    id: string;
+    name: string;
+}>>;
+/** Result of parsing a Google Workspace URL. */
+export interface ParsedGoogleUrl {
+    id: string;
+    type: string;
+    /** Tab ID extracted from a `tab=t.XXXXX` query parameter, if present. */
+    tabId?: string;
+}
+/**
+ * Parse file ID (and optional tab ID) from a Google URL.
+ */
+export declare function parseGoogleUrl(url: string): ParsedGoogleUrl | null;