@promptbook/cli 0.113.0-9 → 0.114.0-0

package/apps/agents-server/src/utils/localChatRunner/persistLocalUserChatJobProgressFromRuntimeLog.ts

@@ -0,0 +1,136 @@
+import type { ChatMessage } from '@promptbook-local/types';
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+import { buildAgentMessageRuntimeLogPathFromFileName } from '../../../../../src/utils/agent-message-runtime/agentMessageRuntimePaths';
+import { resolveAgentMessageRuntimeActivity } from '../../../../../src/utils/agent-message-runtime/resolveAgentMessageRuntimeActivity';
+import { updateUserChatAssistantMessage } from '../userChat/updateUserChatAssistantMessage';
+import type { UserChatJobRecord } from '../userChat/UserChatJobRecord';
+import { resolveLocalAgentRootPath } from './ensureLocalAgentFolder';
+import type { LocalUserChatJobMetadata } from './LocalUserChatJobMetadata';
+
+/**
+ * Maximum number of remembered per-job progress activities before the oldest entry is evicted.
+ *
+ * Keeps the in-process deduplication cache bounded on a long-running server without needing an
+ * explicit cleanup call when a job finishes.
+ *
+ * @private internal constant of `persistLocalUserChatJobProgressFromRuntimeLog`
+ */
+const MAX_TRACKED_PROGRESS_ACTIVITY_JOBS = 500;
+
+/**
+ * Last progress activity already persisted per running job, so unchanged runner output
+ * does not trigger a redundant chat write on every poll.
+ *
+ * @private internal state of `persistLocalUserChatJobProgressFromRuntimeLog`
+ */
+const lastPersistedProgressActivityByJobId = new Map<string, string>();
+
+/**
+ * Remembers the latest persisted progress activity for one job, evicting the oldest tracked job
+ * once the cache grows past its cap.
+ *
+ * @private internal helper of `persistLocalUserChatJobProgressFromRuntimeLog`
+ */
+function rememberPersistedProgressActivity(jobId: string, activity: string): void {
+    lastPersistedProgressActivityByJobId.set(jobId, activity);
+
+    if (lastPersistedProgressActivityByJobId.size <= MAX_TRACKED_PROGRESS_ACTIVITY_JOBS) {
+        return;
+    }
+
+    const oldestJobId = lastPersistedProgressActivityByJobId.keys().next().value;
+    if (oldestJobId !== undefined) {
+        lastPersistedProgressActivityByJobId.delete(oldestJobId);
+    }
+}
+
+/**
+ * Surfaces the local agent runner's live activity as the durable chat progress card.
+ *
+ * While a queued message is being answered, the local runner streams the answering
+ * harness output into a runtime log next to the queued message on the shared agent
+ * folder. This best-effort helper reads that log, resolves the latest user-friendly
+ * assistant narration, and stores it on the still-running assistant placeholder so the
+ * chat shows what the agent is doing right now instead of only rotating `THINKING_MESSAGES`.
+ *
+ * Any failure (missing log, unreadable file, no structured narration yet) is swallowed so
+ * progress reporting can never break the durable chat synchronization itself.
+ */
+export async function persistLocalUserChatJobProgressFromRuntimeLog(
+    job: UserChatJobRecord,
+    metadata: LocalUserChatJobMetadata,
+): Promise<void> {
+    try {
+        const runtimeLogPath = buildAgentMessageRuntimeLogPathFromFileName(
+            join(resolveLocalAgentRootPath(), metadata.agentDirectoryName),
+            metadata.fileName,
+        );
+        const logText = await readOptionalRuntimeLog(runtimeLogPath);
+        if (logText === null) {
+            return;
+        }
+
+        const activity = resolveAgentMessageRuntimeActivity(logText);
+        if (!activity || lastPersistedProgressActivityByJobId.get(job.id) === activity) {
+            return;
+        }
+
+        rememberPersistedProgressActivity(job.id, activity);
+        await updateUserChatAssistantMessage({
+            userId: job.userId,
+            agentPermanentId: job.agentPermanentId,
+            chatId: job.chatId,
+            assistantMessageId: job.assistantMessageId,
+            mutateMessage: (message) => applyRuntimeProgressActivity(message, activity),
+        });
+    } catch (error) {
+        console.warn('[local-chat-runner] progress_update_from_runtime_log_failed', {
+            chatId: job.chatId,
+            jobId: job.id,
+            error,
+        });
+    }
+}
+
+/**
+ * Applies one resolved runner activity onto a still-running assistant placeholder.
+ *
+ * The placeholder is left untouched once it is no longer an empty running message, so a
+ * finished answer or a message that already started streaming content is never overwritten.
+ *
+ * @private internal helper of `persistLocalUserChatJobProgressFromRuntimeLog`
+ */
+function applyRuntimeProgressActivity(message: ChatMessage, activity: string): ChatMessage {
+    const isRunningPlaceholder =
+        message.isComplete === false &&
+        message.lifecycleState === 'running' &&
+        message.content.trim().length === 0;
+
+    if (!isRunningPlaceholder || message.progressCard?.now === activity) {
+        return message;
+    }
+
+    return {
+        ...message,
+        progressCard: {
+            now: activity,
+            items: [],
+            updatedAt: new Date().toISOString() as NonNullable<ChatMessage['progressCard']>['updatedAt'],
+            isVisible: true,
+        },
+    };
+}
+
+/**
+ * Reads one runtime log file, treating a missing log as "no activity yet".
+ *
+ * @private internal helper of `persistLocalUserChatJobProgressFromRuntimeLog`
+ */
+async function readOptionalRuntimeLog(runtimeLogPath: string): Promise<string | null> {
+    try {
+        return await readFile(runtimeLogPath, 'utf-8');
+    } catch {
+        return null;
+    }
+}

package/apps/agents-server/src/utils/localChatRunner/processLocalUserChatJob.ts

@@ -2,6 +2,10 @@ import type { Json } from '@/src/database/schema';
 import { mkdir, readFile, rm, writeFile } from 'fs/promises';
 import { join } from 'path';
 import { parseAgentSource } from '../../../../../src/book-2.0/agent-source/parseAgentSource';
+import {
+    buildAgentMessageRunReportPath,
+    parseAgentMessageRunReport,
+} from '../../../../../src/book-3.0/AgentMessageRunReport';
 import { createUserChatJobFailureDetails } from '../userChat/createUserChatJobFailureDetails';
 import { claimNextQueuedUserChatJob } from '../userChat/claimNextQueuedUserChatJob';
 import { finalizeUserChatJob } from '../userChat/finalizeUserChatJob';
@@ -13,6 +17,7 @@ import { updateUserChatAssistantMessage } from '../userChat/updateUserChatAssist
 import type { UserChatJobRecord } from '../userChat/UserChatJobRecord';
 import type { UserChatJobRow } from '../userChat/UserChatJobRow';
 import { createUserChatRunnerThreadMessages } from '../userChat/userChatMessageLifecycle';
+import { persistUserChatJobRunReport } from '../userChat/userChatJobRunReport';
 import { runWithTaskTerminalCapture } from '../taskTerminal/runWithTaskTerminalCapture';
 import {
     createLocalUserChatJobMetadata,
@@ -32,6 +37,7 @@ import {
     loadLocalAgentSourceSnapshot,
     resolveLocalAgentRootPath,
 } from './ensureLocalAgentFolder';
+import { persistLocalUserChatJobProgressFromRuntimeLog } from './persistLocalUserChatJobProgressFromRuntimeLog';
 
 /**
  * Result of processing one local user chat job.
@@ -218,6 +224,7 @@ async function synchronizeLocalUserChatJob(
         });
 
         if (content) {
+            await persistLocalUserChatJobRunReportIfPresent(job, agentDirectoryPath, metadata);
             await persistUserChatJobTerminalState({
                 job,
                 status: 'COMPLETED',
@@ -264,9 +271,44 @@ async function synchronizeLocalUserChatJob(
         return { didMutate: true, outcome: 'failed' };
     }
 
+    // Note: The message is still being answered — surface the runner's live activity as progress.
+    //       This stays `didMutate: false` so it never triggers extra worker ticks; the next chat
+    //       detail poll reloads the chat and shows the freshly persisted progress card.
+    await persistLocalUserChatJobProgressFromRuntimeLog(job, metadata);
+
     return { didMutate: false, outcome: 'waiting' };
 }
 
+/**
+ * Persists the runner-produced report sidecar into the job before completion when it exists.
+ *
+ * The report is best-effort telemetry shown in the admin task details, so any read or
+ * persistence failure only logs a warning instead of failing the finished chat answer.
+ */
+async function persistLocalUserChatJobRunReportIfPresent(
+    job: UserChatJobRecord,
+    agentDirectoryPath: string,
+    metadata: LocalUserChatJobMetadata,
+): Promise<void> {
+    try {
+        const reportFileContent = await readOptionalTextFile(
+            join(agentDirectoryPath, buildAgentMessageRunReportPath(metadata.finishedPath)),
+        );
+        const report = reportFileContent === null ? null : parseAgentMessageRunReport(reportFileContent);
+        if (!report) {
+            return;
+        }
+
+        await persistUserChatJobRunReport(job, report);
+    } catch (error) {
+        console.warn('[local-chat-runner] run_report_sync_failed', {
+            chatId: job.chatId,
+            jobId: job.id,
+            error,
+        });
+    }
+}
+
 /**
  * Persists local-runner metadata after one chat thread has been mirrored to disk.
  */

package/apps/agents-server/src/utils/manGoOnboarding/manGoOnboardingAgentBooks.ts

@@ -0,0 +1,86 @@
+import { spaceTrim } from 'spacetrim';
+
+/**
+ * Agent book copied from the manGo onboarding experiment and used as the drafting specialist.
+ *
+ * @private internal constant of manGo onboarding agent utilities
+ */
+export const MAN_GO_DRAFT_EXPERT_BOOK = spaceTrim(`
+    Book language expert
+
+    LANGUAGE Čeština
+`);
+
+/**
+ * Agent book copied from the manGo onboarding experiment and used to convert free-form drafts to Book language.
+ *
+ * @private internal constant of manGo onboarding agent utilities
+ */
+export const MAN_GO_BOOK_EXPERT_BOOK = spaceTrim(`
+    Book expert
+
+    PERSONA You are expert in book language
+    RULE You can work with the book language and write, modify, or consult the agents based on the book language.
+
+    KNOWLEDGE https://core.ptbk.io/api/docs/book-language.md
+
+    RULE When creating agents, use code blocks with book language:
+
+    For example:
+
+    \`\`\`book
+    Paul Smith & Associés
+
+    PERSONA You are a company lawyer.
+    Your job is to provide legal advice and support to the company and its employees.
+    You are knowledgeable, professional, and detail-oriented.
+    USE SEARCH ENGINE
+    \`\`\`
+
+    RULE You are writing a book in the language the user will ask you.
+    Commitment keywords like "RULE" or "KNOWLEDGE" are always keywords in English
+
+    USER MESSAGE
+    Create an AI agent that teaches me to speak Italian
+
+    AGENT MESSAGE
+
+    \`\`\`book
+    Mario Ferrari
+
+    PERSONA You are an Italian teacher.
+    You teach the Italian language.
+    You are knowledgeable, professional and detail-oriented.
+    RULE Do not chat about anything other than Italian. You can speak Italian or discuss Italian grammar in English.
+    LANGUAGES Italian, English
+    \`\`\`
+
+    USER MESSAGE
+    Vytvoř mi AI agenta, který mě učí mluvit italsky
+
+    AGENT MESSAGE
+
+    \`\`\`book
+    Mario Ferrari
+
+    PERSONA Jste učitel italštiny.
+    Učíte italský jazyk.
+    Jste znalý, profesionální a dbáte na detaily.
+    RULE Nepovídejte si o ničem jiném než o italštině. Můžete mluvit italsky nebo diskutovat o italské gramatice v angličtině.
+    LANGUAGES Italština, čeština, angličtina
+    \`\`\`
+
+    CLOSED
+`);
+
+/**
+ * Reviewer book copied from the manGo onboarding experiment for step 4 answer checks.
+ *
+ * @private internal constant of manGo onboarding agent utilities
+ */
+export const MAN_GO_REPLY_REVIEWER_BOOK = spaceTrim(`
+    Kontrolor odpovědí
+
+    PERSONA Jste přísný kontrolor odpovědí zákaznické podpory. Porovnáváte návrh odpovědi s definicí agenta (book) - tonalita, délka, jazyk, zakázaná témata a dodržení instrukcí.
+    RULE Odpovídáte výhradně požadovaným JSON polem v jednom \`json\` bloku, nic jiného.
+`);