codingbuddy 2.3.2 → 2.3.4

package/dist/src/mcp/mcp.module.js

@@ -17,6 +17,8 @@ const analyzer_module_1 = require("../analyzer/analyzer.module");
 const agent_module_1 = require("../agent/agent.module");
 const checklist_module_1 = require("../checklist/checklist.module");
 const context_module_1 = require("../context/context.module");
+const session_module_1 = require("../session/session.module");
+const state_module_1 = require("../state/state.module");
 const skill_recommendation_service_1 = require("../skill/skill-recommendation.service");
 const language_service_1 = require("../shared/language.service");
 const model_1 = require("../model");
@@ -29,6 +31,7 @@ const handlers = [
     handlers_1.ModeHandler,
     handlers_1.ChecklistContextHandler,
     handlers_1.ConventionsHandler,
+    handlers_1.SessionHandler,
 ];
 let McpModule = class McpModule {
 };
@@ -43,6 +46,8 @@ exports.McpModule = McpModule = __decorate([
             agent_module_1.AgentModule,
             checklist_module_1.ChecklistModule,
             context_module_1.ContextModule,
+            session_module_1.SessionModule,
+            state_module_1.StateModule,
         ],
         controllers: [mcp_controller_1.McpController],
         providers: [

package/dist/src/mcp/mcp.module.js.map

@@ -1 +1 @@
-{"version":3,"file":"mcp.module.js","sourceRoot":"","sources":["../../../src/mcp/mcp.module.ts"],"names":[],"mappings":";;;;;;;;;AAAA,2CAAwC;AACxC,+CAA2C;AAC3C,qDAAiD;AACjD,wDAAoD;AACpD,8DAA0D;AAC1D,2DAAkE;AAClE,iEAA6D;AAC7D,wDAAoD;AACpD,oEAAgE;AAChE,8DAA0D;AAC1D,wFAAmF;AACnF,iEAA6D;AAC7D,oCAAgD;AAGhD,yCASoB;AAEpB,MAAM,QAAQ,GAAG;IACf,uBAAY;IACZ,wBAAa;IACb,uBAAY;IACZ,uBAAY;IACZ,sBAAW;IACX,kCAAuB;IACvB,6BAAkB;CACnB,CAAC;AA6BK,IAAM,SAAS,GAAf,MAAM,SAAS;CAAG,CAAA;AAAZ,8BAAS;oBAAT,SAAS;IA3BrB,IAAA,eAAM,EAAC;QACN,OAAO,EAAE;YACP,0BAAW;YACX,8BAAa;YACb,uCAAuB;YACvB,gCAAc;YACd,0BAAW;YACX,kCAAe;YACf,8BAAa;SACd;QACD,WAAW,EAAE,CAAC,8BAAa,CAAC;QAC5B,SAAS,EAAE;YACT,wBAAU;YACV,yDAA0B;YAC1B,kCAAe;YACf,4BAAoB;YACpB,GAAG,QAAQ;YACX;gBACE,OAAO,EAAE,wBAAa;gBACtB,UAAU,EAAE,CACV,GAAG,gBAA2D,EAC9D,EAAE,CAAC,gBAAgB;gBACrB,MAAM,EAAE,QAAQ;aACjB;SACF;QACD,OAAO,EAAE,CAAC,wBAAU,CAAC;KACtB,CAAC;GACW,SAAS,CAAG"}
+{"version":3,"file":"mcp.module.js","sourceRoot":"","sources":["../../../src/mcp/mcp.module.ts"],"names":[],"mappings":";;;;;;;;;AAAA,2CAAwC;AACxC,+CAA2C;AAC3C,qDAAiD;AACjD,wDAAoD;AACpD,8DAA0D;AAC1D,2DAAkE;AAClE,iEAA6D;AAC7D,wDAAoD;AACpD,oEAAgE;AAChE,8DAA0D;AAC1D,8DAA0D;AAC1D,wDAAoD;AACpD,wFAAmF;AACnF,iEAA6D;AAC7D,oCAAgD;AAGhD,yCAUoB;AAEpB,MAAM,QAAQ,GAAG;IACf,uBAAY;IACZ,wBAAa;IACb,uBAAY;IACZ,uBAAY;IACZ,sBAAW;IACX,kCAAuB;IACvB,6BAAkB;IAClB,yBAAc;CACf,CAAC;AA+BK,IAAM,SAAS,GAAf,MAAM,SAAS;CAAG,CAAA;AAAZ,8BAAS;oBAAT,SAAS;IA7BrB,IAAA,eAAM,EAAC;QACN,OAAO,EAAE;YACP,0BAAW;YACX,8BAAa;YACb,uCAAuB;YACvB,gCAAc;YACd,0BAAW;YACX,kCAAe;YACf,8BAAa;YACb,8BAAa;YACb,0BAAW;SACZ;QACD,WAAW,EAAE,CAAC,8BAAa,CAAC;QAC5B,SAAS,EAAE;YACT,wBAAU;YACV,yDAA0B;YAC1B,kCAAe;YACf,4BAAoB;YACpB,GAAG,QAAQ;YACX;gBACE,OAAO,EAAE,wBAAa;gBACtB,UAAU,EAAE,CACV,GAAG,gBAA2D,EAC9D,EAAE,CAAC,gBAAgB;gBACrB,MAAM,EAAE,QAAQ;aACjB;SACF;QACD,OAAO,EAAE,CAAC,wBAAU,CAAC;KACtB,CAAC;GACW,SAAS,CAAG"}

package/dist/src/session/index.d.ts

@@ -0,0 +1,3 @@
+export { SessionModule } from './session.module';
+export { SessionService } from './session.service';
+export type { SessionDocument, SessionSection, SessionMetadata, CreateSessionOptions, UpdateSessionOptions, SessionOperationResult, } from './session.types';

package/dist/src/session/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionService = exports.SessionModule = void 0;
+var session_module_1 = require("./session.module");
+Object.defineProperty(exports, "SessionModule", { enumerable: true, get: function () { return session_module_1.SessionModule; } });
+var session_service_1 = require("./session.service");
+Object.defineProperty(exports, "SessionService", { enumerable: true, get: function () { return session_service_1.SessionService; } });
+//# sourceMappingURL=index.js.map

package/dist/src/session/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/session/index.ts"],"names":[],"mappings":";;;AAAA,mDAAiD;AAAxC,+GAAA,aAAa,OAAA;AACtB,qDAAmD;AAA1C,iHAAA,cAAc,OAAA"}

package/dist/src/session/session.module.d.ts

@@ -0,0 +1,2 @@
+export declare class SessionModule {
+}

package/dist/src/session/session.module.js

@@ -0,0 +1,23 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionModule = void 0;
+const common_1 = require("@nestjs/common");
+const session_service_1 = require("./session.service");
+const config_module_1 = require("../config/config.module");
+let SessionModule = class SessionModule {
+};
+exports.SessionModule = SessionModule;
+exports.SessionModule = SessionModule = __decorate([
+    (0, common_1.Module)({
+        imports: [config_module_1.CodingBuddyConfigModule],
+        providers: [session_service_1.SessionService],
+        exports: [session_service_1.SessionService],
+    })
+], SessionModule);
+//# sourceMappingURL=session.module.js.map

package/dist/src/session/session.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.module.js","sourceRoot":"","sources":["../../../src/session/session.module.ts"],"names":[],"mappings":";;;;;;;;;AAAA,2CAAwC;AACxC,uDAAmD;AACnD,2DAAkE;AAO3D,IAAM,aAAa,GAAnB,MAAM,aAAa;CAAG,CAAA;AAAhB,sCAAa;wBAAb,aAAa;IALzB,IAAA,eAAM,EAAC;QACN,OAAO,EAAE,CAAC,uCAAuB,CAAC;QAClC,SAAS,EAAE,CAAC,gCAAc,CAAC;QAC3B,OAAO,EAAE,CAAC,gCAAc,CAAC;KAC1B,CAAC;GACW,aAAa,CAAG"}

package/dist/src/session/session.service.d.ts

@@ -0,0 +1,33 @@
+import type { SessionDocument, CreateSessionOptions, UpdateSessionOptions, SessionOperationResult } from './session.types';
+import { ConfigService } from '../config/config.service';
+export declare class SessionService {
+    private readonly configService;
+    private readonly logger;
+    private readonly sessionCache;
+    private activeSessionId;
+    private activeSessionTimestamp;
+    constructor(configService: ConfigService);
+    private isCacheValid;
+    private getFromCache;
+    private addToCache;
+    private invalidateCache;
+    private invalidateSession;
+    private getSessionsDir;
+    private ensureSessionsDir;
+    private validateSessionId;
+    private getSessionFilePath;
+    private validateTitle;
+    private generateFilename;
+    createSession(options: CreateSessionOptions): Promise<SessionOperationResult>;
+    getSession(sessionId: string): Promise<SessionDocument | null>;
+    getActiveSession(): Promise<SessionDocument | null>;
+    updateSession(options: UpdateSessionOptions): Promise<SessionOperationResult>;
+    getRecommendedActAgent(sessionId: string): Promise<{
+        agent: string;
+        confidence: number;
+    } | null>;
+    private serializeDocument;
+    private parseDocument;
+    private parseSectionContentLine;
+    private parseListItem;
+}

package/dist/src/session/session.service.js

@@ -0,0 +1,557 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var SessionService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionService = void 0;
+const common_1 = require("@nestjs/common");
+const fs = require("fs/promises");
+const fs_1 = require("fs");
+const path = require("path");
+const config_service_1 = require("../config/config.service");
+const SESSIONS_DIR_NAME = 'docs/codingbuddy/sessions';
+const MARKDOWN = {
+    SESSION_HEADER: '# Session:',
+    CREATED_PREFIX: '**Created**:',
+    UPDATED_PREFIX: '**Updated**:',
+    STATUS_PREFIX: '**Status**:',
+    PRIMARY_AGENT_PREFIX: '**Primary Agent**:',
+    RECOMMENDED_ACT_AGENT_PREFIX: '**Recommended ACT Agent**:',
+    SPECIALISTS_PREFIX: '**Specialists**:',
+    SECTION_SEPARATOR: '---',
+    TASK_HEADER: '### Task',
+    DECISIONS_HEADER: '### Decisions',
+    NOTES_HEADER: '### Notes',
+};
+const SESSION_ID_PATTERN = /^[a-z0-9가-힣-]+$/;
+const MAX_SESSION_TITLE_LENGTH = 200;
+const MAX_SLUG_LENGTH = 100;
+const MAX_SESSION_ID_LENGTH = 150;
+const CACHE_TTL_MS = 30_000;
+const MAX_CACHE_SIZE = 100;
+const VALID_SESSION_STATUSES = ['active', 'completed', 'archived'];
+const VALID_SECTION_STATUSES = ['in_progress', 'completed', 'blocked'];
+const SECTION_HEADER_PATTERN = /^## (PLAN|ACT|EVAL|AUTO) \((.+)\)$/;
+const RECOMMENDED_AGENT_PATTERN = /\*\*Recommended ACT Agent\*\*: ([^\s(]+)(?:\s*\(confidence: ([\d.]+)\))?/;
+function isValidSessionStatus(value) {
+    return VALID_SESSION_STATUSES.includes(value);
+}
+function isValidSectionStatus(value) {
+    return VALID_SECTION_STATUSES.includes(value);
+}
+function parseMetadataLine(line, ctx) {
+    if (line.startsWith(MARKDOWN.SESSION_HEADER)) {
+        ctx.metadata.title = line.replace(MARKDOWN.SESSION_HEADER, '').trim();
+        return true;
+    }
+    if (line.startsWith(MARKDOWN.CREATED_PREFIX)) {
+        ctx.metadata.createdAt = line.replace(MARKDOWN.CREATED_PREFIX, '').trim();
+        return true;
+    }
+    if (line.startsWith(MARKDOWN.UPDATED_PREFIX)) {
+        ctx.metadata.updatedAt = line.replace(MARKDOWN.UPDATED_PREFIX, '').trim();
+        return true;
+    }
+    if (line.startsWith(MARKDOWN.STATUS_PREFIX) && !ctx.currentSection) {
+        const statusValue = line.replace(MARKDOWN.STATUS_PREFIX, '').trim();
+        if (isValidSessionStatus(statusValue)) {
+            ctx.metadata.status = statusValue;
+        }
+        return true;
+    }
+    return false;
+}
+function parseSectionHeader(line, ctx) {
+    const match = line.match(SECTION_HEADER_PATTERN);
+    if (!match)
+        return false;
+    if (ctx.currentSection && ctx.currentSection.mode) {
+        ctx.sections.push(ctx.currentSection);
+    }
+    ctx.currentSection = {
+        mode: match[1],
+        timestamp: match[2],
+    };
+    ctx.currentListType = null;
+    return true;
+}
+function parseSectionField(line, section) {
+    if (line.startsWith(MARKDOWN.PRIMARY_AGENT_PREFIX)) {
+        section.primaryAgent = line
+            .replace(MARKDOWN.PRIMARY_AGENT_PREFIX, '')
+            .trim();
+        return true;
+    }
+    if (line.startsWith(MARKDOWN.RECOMMENDED_ACT_AGENT_PREFIX)) {
+        const match = line.match(RECOMMENDED_AGENT_PATTERN);
+        if (match) {
+            section.recommendedActAgent = match[1];
+            if (match[2]) {
+                section.recommendedActAgentConfidence = parseFloat(match[2]);
+            }
+        }
+        return true;
+    }
+    if (line.startsWith(MARKDOWN.SPECIALISTS_PREFIX)) {
+        section.specialists = line
+            .replace(MARKDOWN.SPECIALISTS_PREFIX, '')
+            .trim()
+            .split(',')
+            .map(s => s.trim());
+        return true;
+    }
+    if (line.startsWith(MARKDOWN.STATUS_PREFIX)) {
+        const statusValue = line.replace(MARKDOWN.STATUS_PREFIX, '').trim();
+        if (isValidSectionStatus(statusValue)) {
+            section.status = statusValue;
+        }
+        return true;
+    }
+    return false;
+}
+function parseListHeader(line, section) {
+    if (line === MARKDOWN.TASK_HEADER) {
+        return { matched: true, listType: 'task' };
+    }
+    if (line === MARKDOWN.DECISIONS_HEADER) {
+        section.decisions = [];
+        return { matched: true, listType: 'decisions' };
+    }
+    if (line === MARKDOWN.NOTES_HEADER) {
+        section.notes = [];
+        return { matched: true, listType: 'notes' };
+    }
+    return { matched: false };
+}
+function isContentLine(line) {
+    return (!line.startsWith('#') &&
+        !line.startsWith('**') &&
+        !line.startsWith('-') &&
+        !line.startsWith('---') &&
+        line.trim().length > 0);
+}
+let SessionService = SessionService_1 = class SessionService {
+    constructor(configService) {
+        this.configService = configService;
+        this.logger = new common_1.Logger(SessionService_1.name);
+        this.sessionCache = new Map();
+        this.activeSessionId = null;
+        this.activeSessionTimestamp = 0;
+    }
+    isCacheValid(timestamp) {
+        return Date.now() - timestamp < CACHE_TTL_MS;
+    }
+    getFromCache(sessionId) {
+        const entry = this.sessionCache.get(sessionId);
+        if (entry && this.isCacheValid(entry.timestamp)) {
+            return entry.session;
+        }
+        if (entry) {
+            this.sessionCache.delete(sessionId);
+        }
+        return null;
+    }
+    addToCache(sessionId, session) {
+        if (this.sessionCache.has(sessionId)) {
+            this.sessionCache.delete(sessionId);
+        }
+        while (this.sessionCache.size >= MAX_CACHE_SIZE) {
+            const oldestKey = this.sessionCache.keys().next().value;
+            if (oldestKey !== undefined) {
+                this.sessionCache.delete(oldestKey);
+            }
+            else {
+                break;
+            }
+        }
+        this.sessionCache.set(sessionId, {
+            session,
+            timestamp: Date.now(),
+        });
+    }
+    invalidateCache() {
+        this.sessionCache.clear();
+        this.activeSessionId = null;
+        this.activeSessionTimestamp = 0;
+    }
+    invalidateSession(sessionId) {
+        this.sessionCache.delete(sessionId);
+        if (this.activeSessionId === sessionId) {
+            this.activeSessionId = null;
+            this.activeSessionTimestamp = 0;
+        }
+    }
+    getSessionsDir() {
+        const projectRoot = this.configService.getProjectRoot();
+        return path.join(projectRoot, SESSIONS_DIR_NAME);
+    }
+    ensureSessionsDir() {
+        const sessionsDir = this.getSessionsDir();
+        if (!(0, fs_1.existsSync)(sessionsDir)) {
+            (0, fs_1.mkdirSync)(sessionsDir, { recursive: true });
+            this.logger.log(`Created sessions directory: ${sessionsDir}`);
+        }
+    }
+    validateSessionId(sessionId) {
+        if (!sessionId || sessionId.length === 0) {
+            this.logger.warn(`Session ID is empty: rejected`);
+            return false;
+        }
+        if (sessionId.length > MAX_SESSION_ID_LENGTH) {
+            this.logger.warn(`Session ID exceeds maximum length: rejected`);
+            return false;
+        }
+        if (sessionId.includes('\x00')) {
+            this.logger.warn(`Session ID contains null byte: rejected`);
+            return false;
+        }
+        if (sessionId.includes('..') ||
+            sessionId.includes('/') ||
+            sessionId.includes('\\')) {
+            this.logger.warn(`Session ID contains path traversal: rejected`);
+            return false;
+        }
+        if (!SESSION_ID_PATTERN.test(sessionId)) {
+            this.logger.warn(`Session ID contains invalid characters: rejected`);
+            return false;
+        }
+        return true;
+    }
+    getSessionFilePath(sessionId) {
+        if (!this.validateSessionId(sessionId)) {
+            return null;
+        }
+        const filePath = path.join(this.getSessionsDir(), `${sessionId}.md`);
+        const resolvedPath = path.resolve(filePath);
+        const resolvedSessionsDir = path.resolve(this.getSessionsDir());
+        if (!resolvedPath.startsWith(resolvedSessionsDir + path.sep)) {
+            this.logger.warn(`Session path escaped sessions directory: ${resolvedPath}`);
+            return null;
+        }
+        return filePath;
+    }
+    validateTitle(title) {
+        if (!title || title.trim().length === 0) {
+            return 'Title cannot be empty';
+        }
+        if (title.length > MAX_SESSION_TITLE_LENGTH) {
+            return `Title exceeds maximum length of ${MAX_SESSION_TITLE_LENGTH} characters`;
+        }
+        return null;
+    }
+    generateFilename(title) {
+        const date = new Date().toISOString().split('T')[0];
+        const slug = title
+            .toLowerCase()
+            .replace(/[^a-z0-9가-힣]+/g, '-')
+            .replace(/^-|-$/g, '')
+            .slice(0, MAX_SLUG_LENGTH);
+        return `${date}-${slug}.md`;
+    }
+    async createSession(options) {
+        try {
+            const titleError = this.validateTitle(options.title);
+            if (titleError) {
+                return { success: false, error: titleError };
+            }
+            this.ensureSessionsDir();
+            const filename = this.generateFilename(options.title);
+            const filePath = path.join(this.getSessionsDir(), filename);
+            if ((0, fs_1.existsSync)(filePath)) {
+                return {
+                    success: true,
+                    sessionId: filename.replace('.md', ''),
+                    filePath,
+                    message: `Session already exists: ${filename}`,
+                };
+            }
+            const now = new Date().toISOString();
+            const metadata = {
+                id: filename.replace('.md', ''),
+                title: options.title,
+                createdAt: now,
+                updatedAt: now,
+                status: 'active',
+            };
+            const document = {
+                metadata,
+                sections: [],
+            };
+            const content = this.serializeDocument(document);
+            await fs.writeFile(filePath, content, 'utf-8');
+            this.activeSessionId = null;
+            this.activeSessionTimestamp = 0;
+            this.logger.log(`Created session: ${filename}`);
+            return {
+                success: true,
+                sessionId: metadata.id,
+                filePath,
+                message: `Session created: ${filename}`,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            this.logger.error(`Failed to create session: ${message}`);
+            return {
+                success: false,
+                error: message,
+            };
+        }
+    }
+    async getSession(sessionId) {
+        try {
+            const cached = this.getFromCache(sessionId);
+            if (cached) {
+                return cached;
+            }
+            const filePath = this.getSessionFilePath(sessionId);
+            if (!filePath) {
+                this.logger.debug(`Invalid session ID: ${sessionId}`);
+                return null;
+            }
+            if (!(0, fs_1.existsSync)(filePath)) {
+                this.logger.debug(`Session not found: ${sessionId}`);
+                return null;
+            }
+            const content = await fs.readFile(filePath, 'utf-8');
+            const session = this.parseDocument(content, sessionId);
+            this.addToCache(sessionId, session);
+            return session;
+        }
+        catch (error) {
+            this.logger.error(`Failed to read session ${sessionId}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return null;
+        }
+    }
+    async getActiveSession() {
+        try {
+            if (this.activeSessionId &&
+                this.isCacheValid(this.activeSessionTimestamp)) {
+                const session = await this.getSession(this.activeSessionId);
+                if (session && session.metadata.status === 'active') {
+                    return session;
+                }
+                this.activeSessionId = null;
+                this.activeSessionTimestamp = 0;
+            }
+            const sessionsDir = this.getSessionsDir();
+            if (!(0, fs_1.existsSync)(sessionsDir)) {
+                return null;
+            }
+            const files = await fs.readdir(sessionsDir);
+            const mdFiles = files
+                .filter(f => f.endsWith('.md'))
+                .sort()
+                .reverse();
+            for (const file of mdFiles) {
+                const sessionId = file.replace('.md', '');
+                const session = await this.getSession(sessionId);
+                if (session && session.metadata.status === 'active') {
+                    this.activeSessionId = sessionId;
+                    this.activeSessionTimestamp = Date.now();
+                    return session;
+                }
+            }
+            return null;
+        }
+        catch (error) {
+            this.logger.error(`Failed to get active session: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return null;
+        }
+    }
+    async updateSession(options) {
+        try {
+            const session = await this.getSession(options.sessionId);
+            if (!session) {
+                return {
+                    success: false,
+                    error: `Session not found: ${options.sessionId}`,
+                };
+            }
+            const now = new Date().toISOString();
+            const timestamp = new Date().toLocaleString('ko-KR', {
+                hour: '2-digit',
+                minute: '2-digit',
+                hour12: false,
+            });
+            const existingIndex = session.sections.findIndex(s => s.mode === options.section.mode);
+            const section = {
+                ...options.section,
+                timestamp: options.section.timestamp || timestamp,
+            };
+            if (existingIndex >= 0) {
+                session.sections[existingIndex] = {
+                    ...session.sections[existingIndex],
+                    ...section,
+                };
+            }
+            else {
+                session.sections.push(section);
+            }
+            session.metadata.updatedAt = now;
+            const filePath = this.getSessionFilePath(options.sessionId);
+            if (!filePath) {
+                return {
+                    success: false,
+                    error: `Invalid session ID: ${options.sessionId}`,
+                };
+            }
+            const content = this.serializeDocument(session);
+            await fs.writeFile(filePath, content, 'utf-8');
+            this.invalidateSession(options.sessionId);
+            this.logger.log(`Updated session ${options.sessionId}: ${options.section.mode} section`);
+            return {
+                success: true,
+                sessionId: options.sessionId,
+                filePath,
+                message: `Session updated: ${options.section.mode} section`,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            this.logger.error(`Failed to update session: ${message}`);
+            return {
+                success: false,
+                error: message,
+            };
+        }
+    }
+    async getRecommendedActAgent(sessionId) {
+        const session = await this.getSession(sessionId);
+        if (!session) {
+            return null;
+        }
+        const planSection = session.sections.find(s => s.mode === 'PLAN');
+        if (planSection?.recommendedActAgent) {
+            return {
+                agent: planSection.recommendedActAgent,
+                confidence: planSection.recommendedActAgentConfidence || 0,
+            };
+        }
+        return null;
+    }
+    serializeDocument(doc) {
+        const lines = [];
+        lines.push(`# Session: ${doc.metadata.title}`);
+        lines.push('');
+        lines.push(`**Created**: ${doc.metadata.createdAt}`);
+        lines.push(`**Updated**: ${doc.metadata.updatedAt}`);
+        lines.push(`**Status**: ${doc.metadata.status}`);
+        lines.push('');
+        lines.push('---');
+        for (const section of doc.sections) {
+            lines.push('');
+            lines.push(`## ${section.mode} (${section.timestamp})`);
+            lines.push('');
+            if (section.primaryAgent) {
+                lines.push(`**Primary Agent**: ${section.primaryAgent}`);
+            }
+            if (section.recommendedActAgent) {
+                const confidence = section.recommendedActAgentConfidence
+                    ? ` (confidence: ${section.recommendedActAgentConfidence})`
+                    : '';
+                lines.push(`**Recommended ACT Agent**: ${section.recommendedActAgent}${confidence}`);
+            }
+            if (section.specialists && section.specialists.length > 0) {
+                lines.push(`**Specialists**: ${section.specialists.join(', ')}`);
+            }
+            if (section.status) {
+                lines.push(`**Status**: ${section.status}`);
+            }
+            lines.push('');
+            if (section.task) {
+                lines.push('### Task');
+                lines.push(section.task);
+                lines.push('');
+            }
+            if (section.decisions && section.decisions.length > 0) {
+                lines.push('### Decisions');
+                for (const decision of section.decisions) {
+                    lines.push(`- ${decision}`);
+                }
+                lines.push('');
+            }
+            if (section.notes && section.notes.length > 0) {
+                lines.push('### Notes');
+                for (const note of section.notes) {
+                    lines.push(`- ${note}`);
+                }
+                lines.push('');
+            }
+            lines.push('---');
+        }
+        return lines.join('\n');
+    }
+    parseDocument(content, sessionId) {
+        const lines = content.split('\n');
+        const ctx = {
+            metadata: {
+                id: sessionId,
+                title: sessionId,
+                createdAt: '',
+                updatedAt: '',
+                status: 'active',
+            },
+            sections: [],
+            currentSection: null,
+            currentListType: null,
+        };
+        for (const line of lines) {
+            if (parseMetadataLine(line, ctx))
+                continue;
+            if (parseSectionHeader(line, ctx))
+                continue;
+            if (ctx.currentSection) {
+                this.parseSectionContentLine(line, ctx);
+            }
+        }
+        if (ctx.currentSection && ctx.currentSection.mode) {
+            ctx.sections.push(ctx.currentSection);
+        }
+        return { metadata: ctx.metadata, sections: ctx.sections };
+    }
+    parseSectionContentLine(line, ctx) {
+        if (!ctx.currentSection)
+            return;
+        const section = ctx.currentSection;
+        if (parseSectionField(line, section))
+            return;
+        const listResult = parseListHeader(line, section);
+        if (listResult.matched) {
+            ctx.currentListType =
+                listResult.listType === 'task' ? null : listResult.listType;
+            return;
+        }
+        if (line.startsWith('- ') && ctx.currentListType) {
+            this.parseListItem(line, section, ctx.currentListType);
+            return;
+        }
+        if (isContentLine(line) && !ctx.currentListType) {
+            section.task = section.task ? `${section.task}\n${line}` : line;
+        }
+    }
+    parseListItem(line, section, listType) {
+        const item = line.replace('- ', '').trim();
+        if (listType === 'decisions') {
+            section.decisions = section.decisions || [];
+            section.decisions.push(item);
+        }
+        else {
+            section.notes = section.notes || [];
+            section.notes.push(item);
+        }
+    }
+};
+exports.SessionService = SessionService;
+exports.SessionService = SessionService = SessionService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [config_service_1.ConfigService])
+], SessionService);
+//# sourceMappingURL=session.service.js.map