sessioncast-cli 1.0.0

package/dist/project/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './manager';
+export * from './executor';
+export * from './relay-client';

package/dist/project/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./manager"), exports);
+__exportStar(require("./executor"), exports);
+__exportStar(require("./relay-client"), exports);

package/dist/project/manager.d.ts

@@ -0,0 +1,79 @@
+import { Project, Workflow, WorkflowStatus, ProjectConfig, AgentStatus } from './types';
+export declare class ProjectManager {
+    private projectPath;
+    private config;
+    constructor(projectPath: string, config?: Partial<ProjectConfig>);
+    /**
+     * Initialize a new project with folder structure
+     */
+    init(projectName?: string): Project;
+    private copyTemplateClaude;
+    private createInitialFiles;
+    private saveProjectConfig;
+    /**
+     * Load existing project
+     */
+    load(): Project | null;
+    /**
+     * Load workflow definition
+     */
+    loadWorkflow(): Workflow | null;
+    /**
+     * Save workflow definition
+     */
+    saveWorkflow(workflow: Workflow): void;
+    /**
+     * Load workflow status
+     */
+    loadStatus(): WorkflowStatus | null;
+    /**
+     * Save workflow status
+     */
+    saveStatus(status: WorkflowStatus): void;
+    /**
+     * Update agent status
+     */
+    updateAgentStatus(agentId: string, agentStatus: Partial<AgentStatus>): void;
+    /**
+     * Create work agent folder with CLAUDE.md
+     */
+    createWorkAgent(agentId: string, agentName: string, tasks: string[]): void;
+    /**
+     * Get tmux session name for an agent
+     * Note: tmux doesn't allow colons in session names, so we use underscores
+     */
+    getTmuxSessionName(agentId: string): string;
+    /**
+     * Check if agent is completed (DONE file exists)
+     */
+    isAgentCompleted(agentId: string): boolean;
+    /**
+     * Get agent output
+     */
+    getAgentOutput(agentId: string): string | null;
+    /**
+     * Append to shared context
+     */
+    appendToContext(content: string): void;
+    /**
+     * Get project path
+     */
+    getProjectPath(): string;
+    /**
+     * Get project ID
+     */
+    getProjectId(): string;
+    /**
+     * Get sources (folders) in the work directory
+     * Returns array of { folder, fileCount }
+     */
+    getSources(): Array<{
+        folder: string;
+        fileCount: number;
+    }>;
+    /**
+     * Get project structure for Claude analysis
+     * Returns a summary of the project's folder structure and key files
+     */
+    getProjectStructure(): string;
+}

package/dist/project/manager.js

@@ -0,0 +1,397 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+class ProjectManager {
+    constructor(projectPath, config = {}) {
+        this.projectPath = path.resolve(projectPath);
+        this.config = {
+            projectId: path.basename(this.projectPath),
+            projectPath: this.projectPath,
+            machineId: config.machineId || 'local',
+            relay: config.relay || '',
+            token: config.token || ''
+        };
+    }
+    /**
+     * Initialize a new project with folder structure
+     */
+    init(projectName) {
+        const name = projectName || path.basename(this.projectPath);
+        // Create folder structure
+        const folders = [
+            'mission',
+            'flow',
+            'shared',
+            'tools/mission-refiner',
+            'tools/pm-agent',
+            'work'
+        ];
+        for (const folder of folders) {
+            const folderPath = path.join(this.projectPath, folder);
+            if (!fs.existsSync(folderPath)) {
+                fs.mkdirSync(folderPath, { recursive: true });
+            }
+        }
+        // Copy template CLAUDE.md files
+        this.copyTemplateClaude('mission-refiner');
+        this.copyTemplateClaude('pm-agent');
+        // Create initial files
+        this.createInitialFiles(name);
+        const project = {
+            name,
+            path: this.projectPath,
+            createdAt: new Date().toISOString(),
+            status: 'initializing'
+        };
+        // Save project config
+        this.saveProjectConfig(project);
+        return project;
+    }
+    copyTemplateClaude(agent) {
+        const templateDir = path.join(__dirname, '../../sample-project/tools', agent);
+        const targetDir = path.join(this.projectPath, 'tools', agent);
+        const claudePath = path.join(templateDir, 'CLAUDE.md');
+        if (fs.existsSync(claudePath)) {
+            fs.copyFileSync(claudePath, path.join(targetDir, 'CLAUDE.md'));
+        }
+    }
+    createInitialFiles(projectName) {
+        // Create mission/README.md
+        const missionReadme = `# Mission
+
+Project: ${projectName}
+
+## Current Mission
+(미션이 정제되면 여기에 기록됩니다)
+
+## History
+(대화 히스토리가 여기에 기록됩니다)
+`;
+        fs.writeFileSync(path.join(this.projectPath, 'mission', 'README.md'), missionReadme);
+        // Create shared/context.md
+        const sharedContext = `# Shared Context
+
+이 파일은 에이전트 간 공유되는 컨텍스트를 저장합니다.
+
+## Project Info
+- Name: ${projectName}
+- Created: ${new Date().toISOString()}
+
+## Agent Outputs
+(각 에이전트의 결과가 여기에 추가됩니다)
+`;
+        fs.writeFileSync(path.join(this.projectPath, 'shared', 'context.md'), sharedContext);
+        // Create .gitignore
+        const gitignore = `# Node
+node_modules/
+
+# Temp files
+*.log
+.DS_Store
+
+# Agent state
+work/**/DONE
+flow/status.yml
+`;
+        fs.writeFileSync(path.join(this.projectPath, '.gitignore'), gitignore);
+    }
+    saveProjectConfig(project) {
+        const configPath = path.join(this.projectPath, '.sessioncast-project.yml');
+        fs.writeFileSync(configPath, yaml.dump(project));
+    }
+    /**
+     * Load existing project
+     */
+    load() {
+        const configPath = path.join(this.projectPath, '.sessioncast-project.yml');
+        if (!fs.existsSync(configPath)) {
+            return null;
+        }
+        return yaml.load(fs.readFileSync(configPath, 'utf-8'));
+    }
+    /**
+     * Load workflow definition
+     */
+    loadWorkflow() {
+        const workflowPath = path.join(this.projectPath, 'flow', 'workflow.yml');
+        if (!fs.existsSync(workflowPath)) {
+            return null;
+        }
+        return yaml.load(fs.readFileSync(workflowPath, 'utf-8'));
+    }
+    /**
+     * Save workflow definition
+     */
+    saveWorkflow(workflow) {
+        const workflowPath = path.join(this.projectPath, 'flow', 'workflow.yml');
+        fs.writeFileSync(workflowPath, yaml.dump(workflow));
+    }
+    /**
+     * Load workflow status
+     */
+    loadStatus() {
+        const statusPath = path.join(this.projectPath, 'flow', 'status.yml');
+        if (!fs.existsSync(statusPath)) {
+            return null;
+        }
+        return yaml.load(fs.readFileSync(statusPath, 'utf-8'));
+    }
+    /**
+     * Save workflow status
+     */
+    saveStatus(status) {
+        const statusPath = path.join(this.projectPath, 'flow', 'status.yml');
+        fs.writeFileSync(statusPath, yaml.dump(status));
+    }
+    /**
+     * Update agent status
+     */
+    updateAgentStatus(agentId, agentStatus) {
+        let status = this.loadStatus();
+        if (!status) {
+            const workflow = this.loadWorkflow();
+            status = {
+                workflow: workflow?.name || 'unknown',
+                startedAt: new Date().toISOString(),
+                status: 'running',
+                agents: {}
+            };
+        }
+        status.agents[agentId] = {
+            ...status.agents[agentId],
+            ...agentStatus
+        };
+        // Update overall status
+        const agentStatuses = Object.values(status.agents);
+        if (agentStatuses.every(a => a.status === 'completed')) {
+            status.status = 'completed';
+        }
+        else if (agentStatuses.some(a => a.status === 'failed')) {
+            status.status = 'failed';
+        }
+        else if (agentStatuses.some(a => a.status === 'running')) {
+            status.status = 'running';
+        }
+        this.saveStatus(status);
+    }
+    /**
+     * Create work agent folder with CLAUDE.md
+     */
+    createWorkAgent(agentId, agentName, tasks) {
+        const agentPath = path.join(this.projectPath, 'work', agentId);
+        if (!fs.existsSync(agentPath)) {
+            fs.mkdirSync(agentPath, { recursive: true });
+        }
+        const claudeContent = `# ${agentName}
+
+## Role
+${agentName} 작업을 수행합니다.
+
+## Tasks
+${tasks.map(t => `- ${t}`).join('\n')}
+
+## Context
+- 프로젝트 경로: ${this.projectPath}
+- 공유 컨텍스트: ../shared/context.md
+
+## Completion
+작업 완료 시:
+1. 결과를 output.md에 기록
+2. DONE 파일 생성: \`touch DONE\`
+
+## Important
+- 모든 작업은 이 폴더 내에서 수행
+- 다른 에이전트의 결과는 ../shared/context.md 참조
+- 에러 발생 시 error.log에 기록
+`;
+        fs.writeFileSync(path.join(agentPath, 'CLAUDE.md'), claudeContent);
+    }
+    /**
+     * Get tmux session name for an agent
+     * Note: tmux doesn't allow colons in session names, so we use underscores
+     */
+    getTmuxSessionName(agentId) {
+        const sanitizedProjectId = this.config.projectId.replace(/[^a-zA-Z0-9_-]/g, '_');
+        return `proj_${sanitizedProjectId}_${agentId}`;
+    }
+    /**
+     * Check if agent is completed (DONE file exists)
+     */
+    isAgentCompleted(agentId) {
+        const donePath = path.join(this.projectPath, 'work', agentId, 'DONE');
+        return fs.existsSync(donePath);
+    }
+    /**
+     * Get agent output
+     */
+    getAgentOutput(agentId) {
+        const outputPath = path.join(this.projectPath, 'work', agentId, 'output.md');
+        if (fs.existsSync(outputPath)) {
+            return fs.readFileSync(outputPath, 'utf-8');
+        }
+        return null;
+    }
+    /**
+     * Append to shared context
+     */
+    appendToContext(content) {
+        const contextPath = path.join(this.projectPath, 'shared', 'context.md');
+        fs.appendFileSync(contextPath, '\n' + content);
+    }
+    /**
+     * Get project path
+     */
+    getProjectPath() {
+        return this.projectPath;
+    }
+    /**
+     * Get project ID
+     */
+    getProjectId() {
+        return this.config.projectId;
+    }
+    /**
+     * Get sources (folders) in the work directory
+     * Returns array of { folder, fileCount }
+     */
+    getSources() {
+        const sources = [];
+        const workPath = path.join(this.projectPath, 'work');
+        if (!fs.existsSync(workPath)) {
+            return sources;
+        }
+        const items = fs.readdirSync(workPath);
+        for (const item of items) {
+            const itemPath = path.join(workPath, item);
+            if (fs.statSync(itemPath).isDirectory()) {
+                // Count files in the folder
+                let fileCount = 0;
+                try {
+                    const countFiles = (dir) => {
+                        let count = 0;
+                        const entries = fs.readdirSync(dir, { withFileTypes: true });
+                        for (const entry of entries) {
+                            if (entry.name.startsWith('.'))
+                                continue; // Skip hidden files
+                            if (entry.isDirectory()) {
+                                count += countFiles(path.join(dir, entry.name));
+                            }
+                            else {
+                                count++;
+                            }
+                        }
+                        return count;
+                    };
+                    fileCount = countFiles(itemPath);
+                }
+                catch {
+                    fileCount = 0;
+                }
+                sources.push({ folder: item, fileCount });
+            }
+        }
+        return sources;
+    }
+    /**
+     * Get project structure for Claude analysis
+     * Returns a summary of the project's folder structure and key files
+     */
+    getProjectStructure() {
+        const lines = [];
+        lines.push(`# Project Structure: ${this.config.projectId}`);
+        lines.push(`Path: ${this.projectPath}`);
+        lines.push('');
+        // List top-level folders
+        const topLevelItems = fs.readdirSync(this.projectPath);
+        lines.push('## Folders:');
+        for (const item of topLevelItems) {
+            const itemPath = path.join(this.projectPath, item);
+            if (fs.statSync(itemPath).isDirectory() && !item.startsWith('.')) {
+                lines.push(`- ${item}/`);
+            }
+        }
+        lines.push('');
+        // List work folder contents (existing agents)
+        const workPath = path.join(this.projectPath, 'work');
+        if (fs.existsSync(workPath)) {
+            lines.push('## Work Agents:');
+            const workItems = fs.readdirSync(workPath);
+            if (workItems.length === 0) {
+                lines.push('- (none yet)');
+            }
+            else {
+                for (const agent of workItems) {
+                    const agentPath = path.join(workPath, agent);
+                    if (fs.statSync(agentPath).isDirectory()) {
+                        lines.push(`- work/${agent}/`);
+                        // Check for key files
+                        const files = fs.readdirSync(agentPath);
+                        for (const file of files) {
+                            lines.push(`    - ${file}`);
+                        }
+                    }
+                }
+            }
+            lines.push('');
+        }
+        // Include shared context summary if exists
+        const contextPath = path.join(this.projectPath, 'shared', 'context.md');
+        if (fs.existsSync(contextPath)) {
+            const contextContent = fs.readFileSync(contextPath, 'utf-8');
+            const preview = contextContent.substring(0, 500);
+            lines.push('## Shared Context (preview):');
+            lines.push('```');
+            lines.push(preview + (contextContent.length > 500 ? '...' : ''));
+            lines.push('```');
+            lines.push('');
+        }
+        // Include mission info if exists
+        const missionPath = path.join(this.projectPath, 'mission', 'README.md');
+        if (fs.existsSync(missionPath)) {
+            const missionContent = fs.readFileSync(missionPath, 'utf-8');
+            const preview = missionContent.substring(0, 300);
+            lines.push('## Mission Info (preview):');
+            lines.push('```');
+            lines.push(preview + (missionContent.length > 300 ? '...' : ''));
+            lines.push('```');
+        }
+        return lines.join('\n');
+    }
+}
+exports.ProjectManager = ProjectManager;

package/dist/project/relay-client.d.ts

@@ -0,0 +1,87 @@
+import { EventEmitter } from 'events';
+interface SourceInfo {
+    folder: string;
+    fileCount: number;
+}
+interface ProjectRelayClientOptions {
+    url: string;
+    token: string;
+    machineId: string;
+    projectId: string;
+    projectName: string;
+    mission?: string;
+    sources?: SourceInfo[];
+}
+export interface MissionStep {
+    id: string;
+    title: string;
+    description: string;
+    agent: string;
+    estimatedTime?: string;
+    dependsOn: string[];
+}
+export interface Decision {
+    id: string;
+    question: string;
+    options: string[];
+    selected?: string;
+    required?: boolean;
+}
+export interface AnalysisResult {
+    steps: MissionStep[];
+    decisions: Decision[];
+}
+export interface Message {
+    type: string;
+    meta?: Record<string, string>;
+    payload?: string;
+    requestId?: string;
+    error?: string;
+    steps?: MissionStep[];
+    decisions?: Decision[];
+}
+export declare class ProjectRelayClient extends EventEmitter {
+    private ws;
+    private options;
+    private isConnected;
+    private destroyed;
+    private reconnectTimer;
+    private pingTimer;
+    constructor(options: ProjectRelayClientOptions);
+    private startPingInterval;
+    private stopPingInterval;
+    connect(): Promise<void>;
+    private registerProject;
+    /**
+     * Update sources list on server
+     */
+    updateSources(sources: SourceInfo[]): void;
+    private handleMessage;
+    private scheduleReconnect;
+    private send;
+    updateStatus(status: string, agents?: Record<string, {
+        status: string;
+        currentTask?: string;
+    }>): void;
+    /**
+     * Send mission analysis response back to server
+     */
+    sendAnalysisResponse(requestId: string, steps: MissionStep[], decisions?: Decision[]): void;
+    /**
+     * Send mission analysis error back to server
+     */
+    sendAnalysisError(requestId: string, error: string): void;
+    /**
+     * Send addSource result back to server
+     */
+    sendAddSourceResult(requestId: string, result: {
+        folder: string;
+        files: string[];
+    }): void;
+    /**
+     * Send addSource error back to server
+     */
+    sendAddSourceError(requestId: string, error: string): void;
+    destroy(): void;
+}
+export {};