@minionry/minion 0.7.36

package/dist/server/services/websocket/index.js

@@ -0,0 +1,5 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export { AutocompleteService } from './autocomplete.js';
+export { ALWAYS_IGNORE_DIRS, FILE_TYPE_MAP, GitignoreRules, getFileType, isIgnored, isImageFile, isPathInSafeLocation, parseGitignore, readFileContent } from './file-utils.js';
+export { WebSocketImproviseHandler } from './handler.js';

package/dist/server/services/websocket/movement-written-files.js

@@ -0,0 +1,26 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export const WRITE_TOOL_NAMES = new Set(['Edit', 'Write', 'MultiEdit', 'NotebookEdit']);
+function writtenPath(toolInput) {
+    if (typeof toolInput !== 'object' || toolInput === null)
+        return undefined;
+    const input = toolInput;
+    const path = typeof input.file_path === 'string' ? input.file_path : input.notebook_path;
+    return typeof path === 'string' && path.length > 0 ? path : undefined;
+}
+export function movementWrittenFiles(movement) {
+    const history = movement.toolUseHistory;
+    if (!Array.isArray(history))
+        return [];
+    const files = [];
+    for (const t of history) {
+        if (!t || typeof t.toolName !== 'string' || !WRITE_TOOL_NAMES.has(t.toolName))
+            continue;
+        if (t.result === undefined || t.isError)
+            continue;
+        const path = writtenPath(t.toolInput);
+        if (path !== undefined && !files.includes(path))
+            files.push(path);
+    }
+    return files;
+}

package/dist/server/services/websocket/msg-id-tracker.js

@@ -0,0 +1,48 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+const DEFAULT_TTL_MS = 15 * 60 * 1000;
+const DEFAULT_MAX_PER_TAB = 512;
+export class MsgIdTracker {
+    ttlMs;
+    maxPerTab;
+    now;
+    tabs = new Map();
+    constructor(ttlMs = DEFAULT_TTL_MS, maxPerTab = DEFAULT_MAX_PER_TAB, now = Date.now) {
+        this.ttlMs = ttlMs;
+        this.maxPerTab = maxPerTab;
+        this.now = now;
+    }
+    recordIfFirst(tabId, msgId) {
+        const entry = this.tabs.get(tabId) ?? { ids: new Map() };
+        this.evictExpired(entry);
+        if (entry.ids.has(msgId)) {
+            entry.ids.set(msgId, this.now());
+            return false;
+        }
+        entry.ids.set(msgId, this.now());
+        this.enforceSizeCap(entry);
+        this.tabs.set(tabId, entry);
+        return true;
+    }
+    forget(tabId) {
+        this.tabs.delete(tabId);
+    }
+    size(tabId) {
+        return this.tabs.get(tabId)?.ids.size ?? 0;
+    }
+    evictExpired(entry) {
+        const cutoff = this.now() - this.ttlMs;
+        for (const [id, ts] of entry.ids) {
+            if (ts < cutoff)
+                entry.ids.delete(id);
+        }
+    }
+    enforceSizeCap(entry) {
+        while (entry.ids.size > this.maxPerTab) {
+            const firstKey = entry.ids.keys().next().value;
+            if (firstKey === undefined)
+                break;
+            entry.ids.delete(firstKey);
+        }
+    }
+}

package/dist/server/services/websocket/plan-board-handlers.js

@@ -0,0 +1,410 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { exportBoardToRepo } from '../plan/board-export.js';
+import { handlePlanPrompt, parseModelDirective, planningAgentTabId, synthesizeBoardPrompt } from '../plan/composer.js';
+import { replaceFrontMatterField } from '../plan/front-matter.js';
+import { getNextBoardId, getNextBoardNumber, NO_SPECS_DIR_ERROR, parseBoardArtifacts, parseBoardDirectory, parsePlanDirectory, resolvePmDir } from '../plan/parser.js';
+import { denyIfViewOnly, executorCache, formatYamlValue } from './plan-helpers.js';
+import { registerBoardInWorkspace } from './plan-transfer-handlers.js';
+import { mergePreUploadedAttachments } from './session-handlers.js';
+export function createEmptyBoardFiles(pmDir, boardId, title, goal) {
+    const boardDir = join(pmDir, 'boards', boardId);
+    for (const dir of ['backlog', 'out', 'reviews', 'logs']) {
+        mkdirSync(join(boardDir, dir), { recursive: true });
+    }
+    const today = new Date().toISOString().split('T')[0];
+    writeFileSync(join(boardDir, 'board.md'), `---
+id: ${boardId}
+title: "${title.replace(/"/g, '\\"')}"
+status: draft
+created: "${today}"
+completed_at: null
+goal: "${goal.replace(/"/g, '\\"')}"
+---
+
+# ${title}
+
+## Goal
+${goal}
+
+## Notes
+`, 'utf-8');
+    writeFileSync(join(boardDir, 'STATE.md'), `---
+project: ../../project.md
+board: board.md
+paused: false
+---
+
+# Board State
+
+## Ready to Work
+
+## In Progress
+
+## Blocked
+
+## Recently Completed
+
+## Warnings
+`, 'utf-8');
+    writeFileSync(join(boardDir, 'progress.md'), '# Board Progress\n', 'utf-8');
+}
+export function handleCreateBoard(ctx, ws, msg, workingDir, permission) {
+    if (denyIfViewOnly(ctx, ws, permission))
+        return;
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir) {
+        ctx.send(ws, { type: 'planError', data: { error: NO_SPECS_DIR_ERROR } });
+        return;
+    }
+    const fullState = parsePlanDirectory(workingDir);
+    if (!fullState)
+        return;
+    const boardId = getNextBoardId(fullState.boards);
+    const boardNum = getNextBoardNumber(fullState.boards);
+    const title = msg.data?.title || `Board ${boardNum}`;
+    const goal = msg.data?.goal || '';
+    createEmptyBoardFiles(pmDir, boardId, title, goal);
+    const workspace = registerBoardInWorkspace(pmDir, boardId);
+    const boardState = parseBoardDirectory(pmDir, boardId);
+    if (boardState) {
+        ctx.broadcastToAll({ type: 'planBoardCreated', data: boardState.board });
+        ctx.broadcastToAll({ type: 'planWorkspaceUpdated', data: workspace });
+    }
+}
+export function applyBoardFieldUpdates(boardMdPath, fields) {
+    let content = readFileSync(boardMdPath, 'utf-8');
+    for (const [key, value] of Object.entries(fields)) {
+        const yamlKey = key.replace(/([A-Z])/g, '_$1').toLowerCase();
+        content = replaceFrontMatterField(content, yamlKey, formatYamlValue(value));
+    }
+    writeFileSync(boardMdPath, content, 'utf-8');
+}
+export function handleUpdateBoard(ctx, ws, msg, workingDir, permission) {
+    if (denyIfViewOnly(ctx, ws, permission))
+        return;
+    const { boardId, fields } = msg.data || {};
+    if (!boardId || !fields) {
+        ctx.send(ws, { type: 'planError', data: { error: 'Board ID and fields required' } });
+        return;
+    }
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir)
+        return;
+    const boardMdPath = join(pmDir, 'boards', boardId, 'board.md');
+    if (!existsSync(boardMdPath)) {
+        ctx.send(ws, { type: 'planError', data: { error: `Board not found: ${boardId}` } });
+        return;
+    }
+    applyBoardFieldUpdates(boardMdPath, fields);
+    const boardState = parseBoardDirectory(pmDir, boardId);
+    if (boardState) {
+        ctx.broadcastToAll({ type: 'planBoardUpdated', data: boardState.board });
+    }
+}
+export function handleArchiveBoard(ctx, ws, msg, workingDir, permission) {
+    if (denyIfViewOnly(ctx, ws, permission))
+        return;
+    const boardId = msg.data?.boardId;
+    if (!boardId) {
+        ctx.send(ws, { type: 'planError', data: { error: 'Board ID required' } });
+        return;
+    }
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir)
+        return;
+    const executor = executorCache.get(workingDir);
+    if (executor) {
+        const snapshot = executor.getExecutionSnapshot();
+        if (snapshot.boardId === boardId && snapshot.status !== 'idle' && snapshot.status !== 'complete' && snapshot.status !== 'error') {
+            executor.stop();
+        }
+    }
+    const workspace = archiveBoardFile(pmDir, boardId);
+    if (!workspace) {
+        ctx.send(ws, { type: 'planError', data: { error: `Board not found: ${boardId}` } });
+        return;
+    }
+    ctx.broadcastToAll({ type: 'planWorkspaceUpdated', data: workspace });
+    const boardState = parseBoardDirectory(pmDir, boardId);
+    if (boardState) {
+        ctx.broadcastToAll({ type: 'planBoardArchived', data: boardState.board });
+    }
+}
+export function archiveBoardFile(pmDir, boardId) {
+    const boardMdPath = join(pmDir, 'boards', boardId, 'board.md');
+    if (!existsSync(boardMdPath))
+        return null;
+    let content = readFileSync(boardMdPath, 'utf-8');
+    content = replaceFrontMatterField(content, 'status', 'archived');
+    writeFileSync(boardMdPath, content, 'utf-8');
+    const workspacePath = join(pmDir, 'workspace.json');
+    if (!existsSync(workspacePath))
+        return null;
+    const workspace = JSON.parse(readFileSync(workspacePath, 'utf-8'));
+    workspace.boardOrder = workspace.boardOrder.filter(id => id !== boardId);
+    if (workspace.activeBoardId === boardId) {
+        workspace.activeBoardId = workspace.boardOrder[0] || null;
+    }
+    writeFileSync(workspacePath, JSON.stringify(workspace, null, 2), 'utf-8');
+    return workspace;
+}
+export function handleRestoreBoard(ctx, ws, msg, workingDir, permission) {
+    if (denyIfViewOnly(ctx, ws, permission))
+        return;
+    const boardId = msg.data?.boardId;
+    if (!boardId) {
+        ctx.send(ws, { type: 'planError', data: { error: 'Board ID required' } });
+        return;
+    }
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir) {
+        ctx.send(ws, { type: 'planError', data: { error: NO_SPECS_DIR_ERROR, boardId } });
+        return;
+    }
+    const workspace = restoreBoardFile(pmDir, boardId);
+    if (!workspace) {
+        ctx.send(ws, { type: 'planError', data: { error: `Board not found: ${boardId}`, boardId } });
+        return;
+    }
+    ctx.broadcastToAll({ type: 'planWorkspaceUpdated', data: workspace });
+    const boardState = parseBoardDirectory(pmDir, boardId);
+    if (boardState) {
+        ctx.broadcastToAll({ type: 'planBoardUpdated', data: boardState.board });
+    }
+}
+export function restoreBoardFile(pmDir, boardId) {
+    const boardMdPath = join(pmDir, 'boards', boardId, 'board.md');
+    if (!existsSync(boardMdPath))
+        return null;
+    let content = readFileSync(boardMdPath, 'utf-8');
+    content = replaceFrontMatterField(content, 'status', 'active');
+    writeFileSync(boardMdPath, content, 'utf-8');
+    const workspacePath = join(pmDir, 'workspace.json');
+    if (!existsSync(workspacePath))
+        return null;
+    const workspace = JSON.parse(readFileSync(workspacePath, 'utf-8'));
+    if (!workspace.boardOrder.includes(boardId)) {
+        workspace.boardOrder.push(boardId);
+    }
+    workspace.activeBoardId = boardId;
+    writeFileSync(workspacePath, JSON.stringify(workspace, null, 2), 'utf-8');
+    return workspace;
+}
+export function handleGetBoard(ctx, ws, msg, workingDir) {
+    const boardId = msg.data?.boardId;
+    if (!boardId) {
+        ctx.send(ws, { type: 'planError', data: { error: 'Board ID required' } });
+        return;
+    }
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir) {
+        ctx.send(ws, { type: 'planError', data: { error: NO_SPECS_DIR_ERROR, boardId } });
+        return;
+    }
+    const boardState = parseBoardDirectory(pmDir, boardId);
+    if (!boardState) {
+        ctx.send(ws, { type: 'planError', data: { error: `Board not found: ${boardId}`, boardId } });
+        return;
+    }
+    ctx.send(ws, { type: 'planBoardState', data: boardState });
+}
+export function handleGetBoardState(ctx, ws, msg, workingDir) {
+    handleGetBoard(ctx, ws, msg, workingDir);
+}
+export function handleReorderBoards(ctx, ws, msg, workingDir, permission) {
+    if (denyIfViewOnly(ctx, ws, permission))
+        return;
+    const boardOrder = msg.data?.boardOrder;
+    if (!Array.isArray(boardOrder)) {
+        ctx.send(ws, { type: 'planError', data: { error: 'boardOrder array required' } });
+        return;
+    }
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir)
+        return;
+    const workspace = reorderBoardsFile(pmDir, boardOrder);
+    if (!workspace)
+        return;
+    ctx.broadcastToAll({ type: 'planWorkspaceUpdated', data: workspace });
+}
+export function reorderBoardsFile(pmDir, boardOrder) {
+    const workspacePath = join(pmDir, 'workspace.json');
+    if (!existsSync(workspacePath))
+        return null;
+    const workspace = JSON.parse(readFileSync(workspacePath, 'utf-8'));
+    workspace.boardOrder = boardOrder;
+    writeFileSync(workspacePath, JSON.stringify(workspace, null, 2), 'utf-8');
+    return workspace;
+}
+export function handleSetActiveBoard(ctx, ws, msg, workingDir, permission) {
+    if (denyIfViewOnly(ctx, ws, permission))
+        return;
+    const boardId = msg.data?.boardId;
+    if (!boardId) {
+        ctx.send(ws, { type: 'planError', data: { error: 'Board ID required' } });
+        return;
+    }
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir) {
+        ctx.send(ws, { type: 'planError', data: { error: NO_SPECS_DIR_ERROR, boardId } });
+        return;
+    }
+    const workspacePath = join(pmDir, 'workspace.json');
+    if (!existsSync(workspacePath)) {
+        ctx.send(ws, { type: 'planError', data: { error: 'No workspace.json in the PM directory', boardId } });
+        return;
+    }
+    const workspace = JSON.parse(readFileSync(workspacePath, 'utf-8'));
+    workspace.activeBoardId = boardId;
+    writeFileSync(workspacePath, JSON.stringify(workspace, null, 2), 'utf-8');
+    ctx.broadcastToAll({ type: 'planWorkspaceUpdated', data: workspace });
+    const boardState = parseBoardDirectory(pmDir, boardId);
+    if (boardState) {
+        ctx.send(ws, { type: 'planBoardState', data: boardState });
+    }
+}
+export function handleGetBoardArtifacts(ctx, ws, msg, workingDir) {
+    const boardId = msg.data?.boardId;
+    if (!boardId) {
+        ctx.send(ws, { type: 'planError', data: { error: 'Board ID required' } });
+        return;
+    }
+    const artifacts = parseBoardArtifacts(workingDir, boardId);
+    if (!artifacts) {
+        ctx.send(ws, { type: 'planBoardArtifacts', data: { boardId, progressLog: '', outputFiles: [], reviewResults: [], executionLogs: [] } });
+        return;
+    }
+    ctx.send(ws, { type: 'planBoardArtifacts', data: artifacts });
+}
+export function handleExportBoard(ctx, ws, msg, workingDir, permission) {
+    if (denyIfViewOnly(ctx, ws, permission))
+        return;
+    const { boardId, author } = (msg.data || {});
+    if (!boardId) {
+        ctx.send(ws, { type: 'planError', data: { error: 'Board ID required' } });
+        return;
+    }
+    try {
+        const result = exportBoardToRepo(workingDir, boardId, {
+            author: typeof author === 'string' && author.trim() ? author.trim() : undefined,
+        });
+        ctx.send(ws, {
+            type: 'planBoardExported',
+            data: {
+                boardId: result.boardId,
+                exportDir: '.minionry/board',
+                files: result.files,
+                templateId: result.template.template_id,
+            },
+        });
+    }
+    catch (error) {
+        ctx.send(ws, {
+            type: 'planError',
+            data: { error: error instanceof Error ? error.message : String(error) },
+        });
+    }
+}
+export async function handleChatToBoard(ctx, ws, msg, workingDir, permission) {
+    if (denyIfViewOnly(ctx, ws, permission))
+        return;
+    const { conversation, autoImplement, focusHint, attachments: inlineAttachments } = (msg.data || {});
+    if (!conversation) {
+        ctx.send(ws, { type: 'planError', data: { error: 'Conversation text is required' } });
+        return;
+    }
+    try {
+        const attachments = msg.tabId
+            ? mergePreUploadedAttachments(ctx, msg.tabId, inlineAttachments)
+            : inlineAttachments;
+        const pmDir = resolvePmDir(workingDir);
+        if (!pmDir) {
+            ctx.send(ws, { type: 'planError', data: { error: `${NO_SPECS_DIR_ERROR}. Run planScaffold first.` } });
+            return;
+        }
+        const modelDirective = parseModelDirective(msg.data);
+        const synthesizedPrompt = await synthesizeBoardPrompt({ conversation, focusHint }, { workingDir });
+        const fullState = parsePlanDirectory(workingDir);
+        if (!fullState) {
+            ctx.send(ws, { type: 'planError', data: { error: 'Failed to parse PM directory' } });
+            return;
+        }
+        const boardId = getNextBoardId(fullState.boards);
+        const boardNum = getNextBoardNumber(fullState.boards);
+        const title = `Board ${boardNum}`;
+        const boardDir = join(pmDir, 'boards', boardId);
+        for (const dir of ['backlog', 'out', 'reviews', 'logs']) {
+            mkdirSync(join(boardDir, dir), { recursive: true });
+        }
+        const today = new Date().toISOString().split('T')[0];
+        const goalLine = focusHint || 'Generated from chat conversation';
+        writeFileSync(join(boardDir, 'board.md'), `---
+id: ${boardId}
+title: "${title}"
+status: draft
+created: "${today}"
+completed_at: null
+goal: "${goalLine.replace(/"/g, '\\"')}"
+auto_implement: ${!!autoImplement}
+---
+
+# ${title}
+
+## Goal
+${goalLine}
+
+## Notes
+`, 'utf-8');
+        writeFileSync(join(boardDir, 'STATE.md'), `---
+project: ../../project.md
+board: board.md
+paused: false
+---
+
+# Board State
+
+## Ready to Work
+
+## In Progress
+
+## Blocked
+
+## Recently Completed
+
+## Warnings
+`, 'utf-8');
+        writeFileSync(join(boardDir, 'progress.md'), '# Board Progress\n', 'utf-8');
+        const wsPath = join(pmDir, 'workspace.json');
+        if (!existsSync(wsPath)) {
+            writeFileSync(wsPath, JSON.stringify({ activeBoardId: null, boardOrder: [] }, null, 2), 'utf-8');
+        }
+        const workspace = JSON.parse(readFileSync(wsPath, 'utf-8'));
+        workspace.boardOrder.push(boardId);
+        workspace.activeBoardId = boardId;
+        writeFileSync(wsPath, JSON.stringify(workspace, null, 2), 'utf-8');
+        const boardState = parseBoardDirectory(pmDir, boardId);
+        if (boardState) {
+            ctx.broadcastToAll({ type: 'planBoardCreated', data: boardState.board });
+            ctx.broadcastToAll({ type: 'planWorkspaceUpdated', data: workspace });
+        }
+        ctx.send(ws, {
+            type: 'chatToBoardCreated',
+            data: { boardId, autoImplement: !!autoImplement, synthesizedPrompt },
+        });
+        await handlePlanPrompt(ctx, ws, synthesizedPrompt, workingDir, {
+            boardId,
+            attachments,
+            modelDirective,
+            agentTabId: planningAgentTabId(boardId),
+        });
+    }
+    catch (error) {
+        ctx.send(ws, {
+            type: 'planError',
+            data: { error: error instanceof Error ? error.message : String(error) },
+        });
+    }
+}