@geteigen/cli 0.0.0-stage → 3.0.0

package/dist/shared/askEigen.d.ts

@@ -0,0 +1,190 @@
+/**
+ * Ask Eigen — the workspace Q&A agent. Types shared by the server, web and
+ * desktop bundles. Questions are answered from the team brain (memories,
+ * episodes, rooms, features, PRs) and read-only connected tools, with a
+ * numbered source list and a receipt for every answer.
+ */
+export declare const ASK_PROVIDERS: readonly ["openai", "anthropic"];
+export type AskProvider = (typeof ASK_PROVIDERS)[number];
+export type AskThreadSource = "page" | "room" | "issue" | "palette";
+export interface AskSettings {
+    /** Owners/admins can turn the whole feature off for a workspace. */
+    enabled: boolean;
+    /** Room chats and their captured episodes. */
+    includeRooms: boolean;
+    /** Private-room content, only when the asker is already a member. */
+    includePrivateRooms: boolean;
+    /** Read-only connected tools (Notion, Linear, GitHub, Sentry, …). */
+    includeIntegrations: boolean;
+    /** Days to keep the admin audit log. */
+    retentionDays: number;
+    provider: AskProvider;
+    model: string;
+    /** Maximum numbered sources handed to the model (3–18). */
+    maxSources: number;
+    /** Admin override of the plan's daily question cap; null = plan default. */
+    dailyLimitOverride: number | null;
+}
+export declare const DEFAULT_ASK_SETTINGS: AskSettings;
+export declare function defaultAskModel(provider: AskProvider): string;
+export declare function isAskProvider(v: unknown): v is AskProvider;
+/** Tolerant normalization — stored JSON may predate newer fields. */
+export declare function normalizeAskSettings(raw: unknown): AskSettings;
+/** Per-plan daily question caps. Kept here so web can show the same number. */
+export declare const ASK_PLAN_DAILY_CAPS: Record<string, number>;
+export declare function askDailyCap(plan: string | null | undefined, override: number | null): number;
+export type AskCitationKind = "memory" | "event" | "feature" | "person" | "integration" | "room" | "issue";
+export interface AskSource {
+    /** 1-based marker used in the answer. */
+    n: number;
+    kind: AskCitationKind;
+    id: string | null;
+    title: string;
+    subtitle: string;
+    snippet: string;
+    /** Internal route or external URL; null when there is no detail page. */
+    href: string | null;
+    at: number | null;
+    /** Retrieval score (memories similarity, other sources heuristically ranked). */
+    score: number;
+    /** Whether the answer cited this source. */
+    used: boolean;
+}
+export type AskToolStatus = "ok" | "empty" | "error" | "skipped";
+export interface AskToolTrace {
+    name: string;
+    status: AskToolStatus;
+    count: number;
+    ms: number;
+    detail?: string;
+}
+export interface AskReceipt {
+    at: number;
+    latencyMs: number;
+    provider: string | null;
+    model: string | null;
+    inputTokens: number;
+    outputTokens: number;
+    outcome: AskOutcome;
+    scopes: string[];
+    tools: AskToolTrace[];
+    counts: {
+        memories: number;
+        events: number;
+        features: number;
+        people: number;
+        integrations: number;
+    };
+    memoryIds: string[];
+    privateRoomsExcluded: number;
+}
+export interface AskReceiptDetail extends AskReceipt {
+    sources: AskSource[];
+}
+export type AskOutcome = "answered" | "empty" | "fallback" | "limited" | "disabled" | "error";
+export type AskFeedbackValue = "up" | "down" | "correction";
+export interface AskMessageInfo {
+    id: string;
+    threadId: string;
+    role: "user" | "assistant";
+    content: string;
+    citations: number[];
+    sources: AskSource[];
+    receipt: AskReceipt | null;
+    provider: string | null;
+    model: string | null;
+    inputTokens: number;
+    outputTokens: number;
+    latencyMs: number;
+    createdAt: number;
+    /** The signed-in user's latest feedback on this answer. */
+    feedback?: AskFeedbackValue | null;
+}
+export interface AskThreadInfo {
+    id: string;
+    orgId: string;
+    userId: string;
+    title: string;
+    source: AskThreadSource;
+    roomId: string | null;
+    issueId: string | null;
+    createdAt: number;
+    updatedAt: number;
+    messageCount: number;
+    lastQuestion: string | null;
+}
+export interface AskThreadDetail {
+    thread: AskThreadInfo;
+    messages: AskMessageInfo[];
+}
+export interface AskSettingsResponse {
+    settings: AskSettings;
+    canManage: boolean;
+    plan: string;
+    dailyCap: number;
+    usedToday: number;
+    questionsToday: number;
+    brainConfigured: boolean;
+    modelConfigured: boolean;
+    /** Providers with a server-managed Ask Eigen key available. */
+    availableProviders: AskProvider[];
+}
+export interface AskDigestHighlight {
+    label: string;
+    title: string;
+    href: string | null;
+    at: number;
+}
+export interface AskDigestInfo {
+    kind: "day" | "week" | "none";
+    period: string | null;
+    summary: string;
+    highlights: AskDigestHighlight[];
+    needsYou: AskDigestHighlight[];
+    generatedAt: number | null;
+}
+export interface AskAuditInfo {
+    id: string;
+    userId: string;
+    userName: string | null;
+    threadId: string | null;
+    question: string;
+    outcome: AskOutcome;
+    provider: string | null;
+    model: string | null;
+    citationCount: number;
+    sourceCount: number;
+    inputTokens: number;
+    outputTokens: number;
+    latencyMs: number;
+    createdAt: number;
+}
+export interface AskFeedbackResponse {
+    rating: AskFeedbackValue;
+    memoryId: string | null;
+}
+export declare const ASK_QUESTION_MAX = 1000;
+/** SSE payloads from `POST /api/ask-eigen/:orgId/ask`. */
+export type AskStreamEvent = {
+    type: "meta";
+    threadId: string;
+    userMessageId: string;
+} | {
+    type: "status";
+    stage: "searching" | "reading" | "writing" | "saving";
+} | {
+    type: "sources";
+    sources: AskSource[];
+} | {
+    type: "delta";
+    text: string;
+} | {
+    type: "done";
+    message: AskMessageInfo;
+    thread: AskThreadInfo;
+} | {
+    type: "error";
+    error: string;
+};
+/** Suggested prompts shown on an empty thread. */
+export declare const ASK_SUGGESTIONS: string[];

package/dist/shared/askEigen.js

@@ -0,0 +1,76 @@
+/**
+ * Ask Eigen — the workspace Q&A agent. Types shared by the server, web and
+ * desktop bundles. Questions are answered from the team brain (memories,
+ * episodes, rooms, features, PRs) and read-only connected tools, with a
+ * numbered source list and a receipt for every answer.
+ */
+export const ASK_PROVIDERS = ["openai", "anthropic"];
+export const DEFAULT_ASK_SETTINGS = {
+    enabled: true,
+    includeRooms: true,
+    includePrivateRooms: false,
+    includeIntegrations: true,
+    retentionDays: 90,
+    provider: "openai",
+    model: "gpt-4.1-mini",
+    maxSources: 10,
+    dailyLimitOverride: null,
+};
+const PROVIDER_DEFAULT_MODEL = {
+    openai: "gpt-4.1-mini",
+    anthropic: "claude-sonnet-4-5",
+};
+export function defaultAskModel(provider) {
+    return PROVIDER_DEFAULT_MODEL[provider];
+}
+function bool(v, fallback) {
+    return typeof v === "boolean" ? v : fallback;
+}
+function num(v, fallback, min, max) {
+    const n = typeof v === "number" ? v : Number(v);
+    if (!Number.isFinite(n))
+        return fallback;
+    return Math.min(max, Math.max(min, Math.round(n)));
+}
+export function isAskProvider(v) {
+    return typeof v === "string" && ASK_PROVIDERS.includes(v);
+}
+/** Tolerant normalization — stored JSON may predate newer fields. */
+export function normalizeAskSettings(raw) {
+    const r = raw && typeof raw === "object" ? raw : {};
+    const provider = isAskProvider(r.provider) ? r.provider : DEFAULT_ASK_SETTINGS.provider;
+    const model = typeof r.model === "string" && r.model.trim() ? r.model.trim().slice(0, 80) : defaultAskModel(provider);
+    const override = r.dailyLimitOverride;
+    return {
+        enabled: bool(r.enabled, DEFAULT_ASK_SETTINGS.enabled),
+        includeRooms: bool(r.includeRooms, DEFAULT_ASK_SETTINGS.includeRooms),
+        includePrivateRooms: bool(r.includePrivateRooms, DEFAULT_ASK_SETTINGS.includePrivateRooms),
+        includeIntegrations: bool(r.includeIntegrations, DEFAULT_ASK_SETTINGS.includeIntegrations),
+        retentionDays: num(r.retentionDays, DEFAULT_ASK_SETTINGS.retentionDays, 7, 365),
+        provider,
+        model,
+        maxSources: num(r.maxSources, DEFAULT_ASK_SETTINGS.maxSources, 3, 18),
+        dailyLimitOverride: override === null || override === undefined || override === ""
+            ? null
+            : num(override, 100, 1, 10_000),
+    };
+}
+/** Per-plan daily question caps. Kept here so web can show the same number. */
+export const ASK_PLAN_DAILY_CAPS = {
+    free: 25,
+    team: 500,
+    business: 2000,
+};
+export function askDailyCap(plan, override) {
+    if (typeof override === "number" && Number.isFinite(override) && override > 0)
+        return override;
+    return ASK_PLAN_DAILY_CAPS[plan || "free"] ?? ASK_PLAN_DAILY_CAPS.free;
+}
+export const ASK_QUESTION_MAX = 1000;
+/** Suggested prompts shown on an empty thread. */
+export const ASK_SUGGESTIONS = [
+    "What shipped this week?",
+    "What did we decide about pricing?",
+    "Who worked on auth recently?",
+    "What needs my attention today?",
+];

package/dist/shared/attribution.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Git attribution helpers — turn Steer chat authorship into commit metadata
+ * that shows up in git blame / PR review.
+ */
+export interface SteerAuthor {
+    userId?: string;
+    name: string;
+    email?: string;
+}
+/** Normalize a display name into a noreply-style local-part. */
+export declare function noreplyLocalPart(name: string, userId?: string): string;
+export declare function resolveAuthorEmail(author: SteerAuthor): string;
+export declare function formatCoAuthoredBy(author: SteerAuthor): string;
+/**
+ * Full commit message with optional Co-authored-by trailer.
+ * Trailers must be separated from the subject/body by a blank line.
+ */
+export declare function buildAttributedCommitMessage(summary: string, steeredBy?: SteerAuthor | null): string;
+/**
+ * Instruction injected into agent prompts so local Cursor/Claude CLI runs
+ * (where we don't control git commit ourselves) still attribute the steerer.
+ */
+export declare function attributionPromptSuffix(steeredBy?: SteerAuthor | null): string;
+/** Short line for PR bodies / chat system notes. */
+export declare function steeredByLine(steeredBy?: SteerAuthor | null): string;

package/dist/shared/attribution.js

@@ -0,0 +1,63 @@
+/**
+ * Git attribution helpers — turn Steer chat authorship into commit metadata
+ * that shows up in git blame / PR review.
+ */
+/** Normalize a display name into a noreply-style local-part. */
+export function noreplyLocalPart(name, userId) {
+    const slug = name
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, ".")
+        .replace(/^\.+|\.+$/g, "")
+        .slice(0, 40);
+    if (userId?.trim()) {
+        const id = userId.trim().replace(/[^a-zA-Z0-9_-]/g, "").slice(0, 24);
+        return `${id}+${slug || "steer-user"}`;
+    }
+    return slug || "steer-user";
+}
+export function resolveAuthorEmail(author) {
+    const email = author.email?.trim();
+    if (email && email.includes("@"))
+        return email;
+    return `${noreplyLocalPart(author.name, author.userId)}@users.noreply.github.com`;
+}
+export function formatCoAuthoredBy(author) {
+    const name = author.name.trim() || "Steer user";
+    return `Co-authored-by: ${name} <${resolveAuthorEmail(author)}>`;
+}
+/**
+ * Full commit message with optional Co-authored-by trailer.
+ * Trailers must be separated from the subject/body by a blank line.
+ */
+export function buildAttributedCommitMessage(summary, steeredBy) {
+    const subject = (summary || "steer: agent changes").trim().slice(0, 72);
+    if (!steeredBy?.name?.trim())
+        return subject;
+    return `${subject}\n\n${formatCoAuthoredBy(steeredBy)}`;
+}
+/**
+ * Instruction injected into agent prompts so local Cursor/Claude CLI runs
+ * (where we don't control git commit ourselves) still attribute the steerer.
+ */
+export function attributionPromptSuffix(steeredBy) {
+    if (!steeredBy?.name?.trim())
+        return "";
+    const trailer = formatCoAuthoredBy(steeredBy);
+    return [
+        "",
+        "[Steer attribution]",
+        "When you create a git commit for this work, include this exact trailer",
+        "at the end of the commit message (after a blank line):",
+        "",
+        trailer,
+        "",
+        "Do not invent other co-authors. Keep the subject line concise.",
+    ].join("\n");
+}
+/** Short line for PR bodies / chat system notes. */
+export function steeredByLine(steeredBy) {
+    if (!steeredBy?.name?.trim())
+        return "";
+    return `Steered by: ${steeredBy.name.trim()} <${resolveAuthorEmail(steeredBy)}>`;
+}

package/dist/shared/automations.d.ts

@@ -0,0 +1,136 @@
+export declare const AUTOMATION_MODES: readonly ["auto", "approval", "suggest_only"];
+export type AutomationMode = (typeof AUTOMATION_MODES)[number];
+export declare const TRIGGER_KINDS: readonly ["schedule", "composio_event", "manual"];
+export type AutomationTriggerKind = (typeof TRIGGER_KINDS)[number];
+export declare const MISFIRE_POLICIES: readonly ["skip", "run_once", "catch_up"];
+export type MisfirePolicy = (typeof MISFIRE_POLICIES)[number];
+export type AutomationRunStatus = "queued" | "running" | "awaiting_approval" | "completed" | "failed" | "cancelled";
+export interface AutomationPolicy {
+    /** Hard daily cap for agent runs across every trigger on this automation. */
+    maxRunsPerDay: number;
+    /** Pending tool approvals expire after this many hours. */
+    approvalTtlHours: number;
+    /** A run that exceeds this wall-clock budget is stopped. */
+    maxRunMinutes: number;
+}
+export declare const DEFAULT_AUTOMATION_POLICY: AutomationPolicy;
+/** `maxRunsPerDay` is enforced over this rolling window, independent of any timezone. */
+export declare const RUN_LIMIT_WINDOW_MS: number;
+/**
+ * The reference instant INTERVAL counts from (RFC 5545 DTSTART). Stored in the
+ * trigger config when the schedule is set; older triggers fall back to creation.
+ */
+export declare function scheduleAnchorOf(config: Record<string, unknown>, fallback: number): number;
+export interface ComposioTriggerConfig {
+    connectionId: string;
+    triggerSlug: string;
+    triggerConfig?: Record<string, unknown>;
+    concurrencyKey?: string;
+}
+export type EventFilterCondition = {
+    path: string;
+    equals?: unknown;
+    contains?: unknown;
+    exists?: boolean;
+};
+export interface EventFilter {
+    all?: EventFilterCondition[];
+    any?: EventFilterCondition[];
+}
+export declare function isAutomationMode(value: unknown): value is AutomationMode;
+export declare function parseAutomationMode(value: unknown, fallback?: AutomationMode): AutomationMode;
+export declare function isTriggerKind(value: unknown): value is AutomationTriggerKind;
+export declare function parseTriggerKind(value: unknown): AutomationTriggerKind | null;
+export declare function isMisfirePolicy(value: unknown): value is MisfirePolicy;
+export declare function parseMisfirePolicy(value: unknown): MisfirePolicy;
+export declare function isRunTerminal(status: AutomationRunStatus): boolean;
+export declare function automationNeedsApproval(mode: AutomationMode): boolean;
+export declare function automationAllowsWrites(mode: AutomationMode): boolean;
+export declare function sanitizeAutomationName(raw: unknown): string;
+export declare function sanitizeAutomationPrompt(raw: unknown): string;
+export declare function sanitizeAutomationText(raw: unknown, max?: number): string;
+export declare function normalizeAutomationPolicy(raw: unknown): AutomationPolicy;
+export declare function normalizeEventFilter(raw: unknown): EventFilter | undefined;
+export declare function matchesEventFilter(payload: unknown, filter: EventFilter | undefined): boolean;
+export declare function expandConcurrencyKey(template: string | undefined, triggerId: string, payload: unknown): string;
+export interface AutomationPromptInput {
+    automationId: string;
+    runId: string;
+    name: string;
+    prompt: string;
+    mode: AutomationMode;
+    policy: AutomationPolicy;
+    now: number;
+    event: unknown;
+    source: string;
+    previousAttempt?: string;
+    /** `<steer_artifacts>` block telling the agent how to share files it creates. */
+    artifactRules?: string;
+    /** The automation's memory doc: read first, log to before finishing. */
+    trackingDoc?: TrackingDocRef | null;
+    approvedToolCalls?: Array<{
+        toolName: string;
+        detail: string;
+    }>;
+}
+export declare function buildAutomationPrompt(input: AutomationPromptInput): string;
+export interface TrackingDocRef {
+    id: string;
+    title: string;
+    url: string;
+}
+/**
+ * How a run uses its automation's tracking doc. The doc is the memory
+ * between runs for both fresh agents and room agents.
+ */
+export declare function trackingDocRules(doc: TrackingDocRef): string;
+/**
+ * The turn an automation sends to the room agent it runs as. The agent keeps
+ * its conversation, so this is short: what to do now, plus any event data.
+ */
+export declare function buildRoomRunMessage(input: {
+    name: string;
+    prompt: string;
+    source: string;
+    event: unknown;
+    mode?: "auto" | "approval" | "suggest_only";
+    trackingDoc?: TrackingDocRef | null;
+}): string;
+/** Sent to a resumed session after a paused write was approved. */
+export declare function buildApprovalContinuationPrompt(approvedToolCalls: Array<{
+    toolName: string;
+    detail: string;
+}>): string;
+export declare function summarizeAutomationOutput(raw: string | null | undefined, max?: number): string;
+/**
+ * What the activity timeline should say. The run's report stays on the run;
+ * older events stored that report in the message, so those collapse to a status.
+ */
+export declare function automationActivityMessage(event: {
+    kind: string;
+    message?: string | null;
+}): string;
+interface RruleSpec {
+    freq: "DAILY" | "WEEKLY" | "MONTHLY";
+    interval: number;
+    byHour: number[];
+    byMinute: number[];
+    byDay: number[];
+    byMonthDay: number[];
+    /** WKST: first day of the week (0 = Sunday); decides which weeks INTERVAL skips. */
+    weekStart: number;
+}
+export declare function parseRrule(input: string): RruleSpec;
+/**
+ * Next occurrence strictly after `after`. INTERVAL periods are counted from
+ * `anchor` (the schedule's DTSTART), so the cadence stays fixed no matter
+ * which instant the search starts from, e.g. when catching up after downtime.
+ */
+export declare function nextScheduledAt(input: {
+    rrule: string;
+    timeZone: string;
+    after: number;
+    anchor?: number;
+}): number | null;
+export declare function assertValidSchedule(rrule: string, timeZone: string, after?: number, anchor?: number): number;
+export {};