@foxden-app/foxclaw 0.2.0

package/dist/controller/observer.d.ts

@@ -0,0 +1,16 @@
+import type { AppThreadSnapshot, AppTurnSnapshot } from '../types.js';
+import { type TurnActivityEvent } from './activity.js';
+export interface ObservedTurnCursor {
+    turnId: string;
+    itemTexts: Record<string, string>;
+    completedItemIds: string[];
+}
+export interface ObservedTurnDiff {
+    nextCursor: ObservedTurnCursor;
+    events: TurnActivityEvent[];
+    waitingOnApproval: boolean;
+    completed: boolean;
+}
+export declare function findLiveTurn(snapshot: AppThreadSnapshot): AppTurnSnapshot | null;
+export declare function findLatestTurn(snapshot: AppThreadSnapshot): AppTurnSnapshot | null;
+export declare function diffObservedTurn(cursor: ObservedTurnCursor | null, turn: AppTurnSnapshot, waitingOnApproval: boolean): ObservedTurnDiff;

package/dist/controller/observer.js

@@ -0,0 +1,98 @@
+import { classifyAgentOutput } from './activity.js';
+export function findLiveTurn(snapshot) {
+    for (let index = snapshot.turns.length - 1; index >= 0; index -= 1) {
+        const turn = snapshot.turns[index];
+        if (turn.status === 'inProgress') {
+            return turn;
+        }
+    }
+    return null;
+}
+export function findLatestTurn(snapshot) {
+    return snapshot.turns.at(-1) ?? null;
+}
+export function diffObservedTurn(cursor, turn, waitingOnApproval) {
+    const baseCursor = cursor && cursor.turnId === turn.turnId
+        ? {
+            turnId: cursor.turnId,
+            itemTexts: { ...cursor.itemTexts },
+            completedItemIds: [...cursor.completedItemIds],
+        }
+        : {
+            turnId: turn.turnId,
+            itemTexts: {},
+            completedItemIds: [],
+        };
+    const completedIds = new Set(baseCursor.completedItemIds);
+    const events = [];
+    const agentItems = turn.items.filter(isRelayableAgentItem);
+    for (const item of agentItems) {
+        const previousText = baseCursor.itemTexts[item.itemId];
+        const nextText = item.text || '';
+        if (previousText === undefined) {
+            events.push({
+                kind: 'agent_message_started',
+                turnId: turn.turnId,
+                itemId: item.itemId,
+                phase: item.phase,
+                outputKind: classifyObservedOutput(item, false),
+                isPlan: item.type.toLowerCase() === 'plan',
+            });
+            if (nextText) {
+                events.push({
+                    kind: 'agent_message_delta',
+                    turnId: turn.turnId,
+                    itemId: item.itemId,
+                    delta: nextText,
+                    outputKind: classifyObservedOutput(item, false),
+                    isPlan: item.type.toLowerCase() === 'plan',
+                });
+            }
+        }
+        else if (nextText.length > previousText.length) {
+            events.push({
+                kind: 'agent_message_delta',
+                turnId: turn.turnId,
+                itemId: item.itemId,
+                delta: nextText.slice(previousText.length),
+                outputKind: classifyObservedOutput(item, false),
+                isPlan: item.type.toLowerCase() === 'plan',
+            });
+        }
+        baseCursor.itemTexts[item.itemId] = nextText;
+    }
+    for (let index = 0; index < agentItems.length; index += 1) {
+        const item = agentItems[index];
+        const itemIsCompleted = turn.status !== 'inProgress' || index < agentItems.length - 1;
+        if (!itemIsCompleted || completedIds.has(item.itemId)) {
+            continue;
+        }
+        completedIds.add(item.itemId);
+        events.push({
+            kind: 'agent_message_completed',
+            turnId: turn.turnId,
+            itemId: item.itemId,
+            phase: item.phase,
+            text: baseCursor.itemTexts[item.itemId] ?? item.text ?? null,
+            outputKind: classifyObservedOutput(item, true),
+            isPlan: item.type.toLowerCase() === 'plan',
+        });
+    }
+    return {
+        nextCursor: {
+            turnId: baseCursor.turnId,
+            itemTexts: baseCursor.itemTexts,
+            completedItemIds: [...completedIds],
+        },
+        events,
+        waitingOnApproval,
+        completed: turn.status !== 'inProgress',
+    };
+}
+function isRelayableAgentItem(item) {
+    const normalizedType = item.type.toLowerCase();
+    return normalizedType === 'agentmessage' || normalizedType === 'assistantmessage' || normalizedType === 'plan';
+}
+function classifyObservedOutput(item, completed) {
+    return item.type.toLowerCase() === 'plan' ? 'commentary' : classifyAgentOutput(item.phase, completed);
+}

package/dist/controller/presentation.d.ts

@@ -0,0 +1,80 @@
+import type { AccessPresetValue, ActiveTurnMessageMode, AppLocale, AppThread, ApprovalPolicyValue, ChatSessionSettings, CollaborationModeValue, ModelInfo, ReasoningEffortValue, SandboxModeValue } from '../types.js';
+import type { ResolvedAccessMode } from './access.js';
+type InlineButton = {
+    text: string;
+    callback_data: string;
+};
+export type SetupFocusSection = 'overview' | 'model' | 'effort' | 'fast' | 'access' | 'mode' | 'active';
+export interface SetupPanelContext {
+    focus: SetupFocusSection;
+    models: ModelInfo[];
+    settings: ChatSessionSettings | null;
+    access: ResolvedAccessMode;
+}
+interface ThreadLike {
+    /** 1-based global ordinal for this row (pagination); keyboard and /open must match. */
+    index?: number;
+    threadId: string;
+    name: string | null;
+    preview: string;
+    cwd: string | null;
+    modelProvider: string | null;
+    status: AppThread['status'];
+    updatedAt: number;
+    archived?: boolean;
+}
+/** Pagination + filter context for the threads panel (Telegram inline keyboard). */
+export interface ThreadListPresentationState {
+    offset: number;
+    pageSize: number;
+    hasPreviousPage: boolean;
+    hasNextPage: boolean;
+    searchTerm: string | null;
+    archived?: boolean;
+}
+export declare function formatThreadsMessage(locale: AppLocale, threads: ThreadLike[], currentThreadId: string | null, searchTerm?: string | null, listState?: ThreadListPresentationState): string;
+export declare function buildThreadsKeyboard(locale: AppLocale, threads: ThreadLike[]): Array<Array<{
+    text: string;
+    callback_data: string;
+}>>;
+/** Threads keyboard plus Prev/Next and optional clear-filter row (Telegram only). */
+export declare function buildThreadListKeyboard(locale: AppLocale, threads: ThreadLike[], listState: ThreadListPresentationState): Array<Array<{
+    text: string;
+    callback_data: string;
+}>>;
+export declare function formatWhereMessage(locale: AppLocale, thread: AppThread, settings: ChatSessionSettings | null, defaultCwd: string, access: ResolvedAccessMode, fastLabel?: string): string;
+export declare function formatCollaborationModeLabel(locale: AppLocale, mode: CollaborationModeValue | null | undefined): string;
+export declare function formatAccessSettingsMessage(locale: AppLocale, access: ResolvedAccessMode): string;
+export declare function buildAccessSettingsKeyboard(locale: AppLocale, access: ResolvedAccessMode): InlineButton[][];
+/** Threads row shape for Weixin copy-paste lines (matches cached thread list fields). */
+export interface WeixinCopyPasteThreadRow {
+    threadId: string;
+    name: string | null;
+    preview: string;
+    archived?: boolean;
+}
+export declare function formatWeixinThreadsCopyPaste(locale: AppLocale, threads: WeixinCopyPasteThreadRow[], searchTerm?: string | null, 
+/** 0-based offset so /open numbers align with cached global indices when paginating. */
+pageOffset?: number): string;
+export declare function formatWeixinModelCopyPaste(locale: AppLocale, models: ModelInfo[], settings: ChatSessionSettings | null): string;
+export declare function formatWeixinAccessCopyPaste(locale: AppLocale): string;
+export declare function formatWeixinWhereNavCopyPaste(locale: AppLocale, hasBinding: boolean, defaultCwd?: string): string;
+export declare function formatSetupPanelMessage(locale: AppLocale, ctx: SetupPanelContext): string;
+export declare function buildSetupPanelKeyboard(locale: AppLocale, ctx: SetupPanelContext): InlineButton[][];
+export declare function resolveSetupSummaryLine(ctx: SetupPanelContext, locale?: AppLocale): string;
+export declare function formatServiceTierStatusLabel(locale: AppLocale, model: ModelInfo | null, serviceTier: string | null | undefined): string;
+export declare function formatActiveTurnMessageModeLabel(locale: AppLocale, mode: ActiveTurnMessageMode | null | undefined): string;
+export declare function resolveActiveTurnMessageMode(mode: ActiveTurnMessageMode | null | undefined): ActiveTurnMessageMode;
+export declare function formatModelSettingsMessage(locale: AppLocale, models: ModelInfo[], settings: ChatSessionSettings | null): string;
+export declare function buildModelSettingsKeyboard(locale: AppLocale, models: ModelInfo[], settings: ChatSessionSettings | null): InlineButton[][];
+export declare function resolveRequestedModel(models: ModelInfo[], requested: string): ModelInfo | null;
+export declare function resolveCurrentModel(models: ModelInfo[], currentModel: string | null): ModelInfo | null;
+export declare function normalizeRequestedEffort(value: string): ReasoningEffortValue | null;
+export declare function clampEffortToModel(model: ModelInfo | null, effort: ReasoningEffortValue | null): {
+    effort: ReasoningEffortValue | null;
+    adjustedFrom: ReasoningEffortValue | null;
+};
+export declare function formatAccessPresetLabel(locale: AppLocale, preset: AccessPresetValue): string;
+export declare function formatApprovalPolicyLabel(locale: AppLocale, policy: ApprovalPolicyValue): string;
+export declare function formatSandboxModeLabel(locale: AppLocale, mode: SandboxModeValue): string;
+export {};