coaiajs 0.1.0

package/dist/src/pde/session-manager.js

@@ -0,0 +1,205 @@
+/**
+ * Session Manager — JSONL persistence for PDE sessions in .coaia/pde/<UUID>.jsonl
+ * Ported from coaia-pde/src/session-manager.ts
+ */
+import { promises as fs } from 'fs';
+import path from 'path';
+import { v4 as uuidv4 } from 'uuid';
+function serializeEntity(entity) {
+    return JSON.stringify({ type: 'entity', ...entity });
+}
+function serializeRelation(relation) {
+    return JSON.stringify({ type: 'relation', ...relation });
+}
+export class SessionManager {
+    baseDir;
+    constructor(baseDir) {
+        this.baseDir = baseDir || path.join(process.cwd(), '.coaia', 'pde');
+    }
+    getSessionPath(sessionId) {
+        return path.join(this.baseDir, `${sessionId}.jsonl`);
+    }
+    async ensureBaseDir() {
+        await fs.mkdir(this.baseDir, { recursive: true });
+    }
+    async initSession(originalPrompt, masterChartId, pdeDecompositionId) {
+        await this.ensureBaseDir();
+        const sessionId = uuidv4();
+        const now = new Date().toISOString();
+        const session = {
+            type: 'pde_session',
+            sessionId,
+            originalPrompt,
+            masterChartId,
+            pdeDecompositionId,
+            createdAt: now,
+            updatedAt: now,
+            status: 'active'
+        };
+        const sessionPath = this.getSessionPath(sessionId);
+        await fs.writeFile(sessionPath, JSON.stringify(session) + '\n');
+        return session;
+    }
+    async loadSession(sessionId) {
+        const sessionPath = this.getSessionPath(sessionId);
+        const data = await fs.readFile(sessionPath, 'utf-8');
+        const lines = data.split('\n').filter(line => line.trim());
+        let session = null;
+        const entities = [];
+        const relations = [];
+        for (const line of lines) {
+            const item = JSON.parse(line);
+            if (item.type === 'pde_session') {
+                session = item;
+            }
+            else if (item.type === 'entity') {
+                const { type: _discriminator, ...entity } = item;
+                entities.push(entity);
+            }
+            else if (item.type === 'relation') {
+                const { type: _discriminator, ...relation } = item;
+                relations.push(relation);
+            }
+        }
+        if (!session) {
+            throw new Error(`Session ${sessionId} not found or corrupted`);
+        }
+        return { session, entities, relations };
+    }
+    async appendEntity(sessionId, entity) {
+        const sessionPath = this.getSessionPath(sessionId);
+        await fs.appendFile(sessionPath, serializeEntity(entity) + '\n');
+    }
+    async appendRelation(sessionId, relation) {
+        const sessionPath = this.getSessionPath(sessionId);
+        await fs.appendFile(sessionPath, serializeRelation(relation) + '\n');
+    }
+    async updateSession(sessionId, updates) {
+        const { session, entities, relations } = await this.loadSession(sessionId);
+        const updatedSession = { ...session, ...updates, updatedAt: new Date().toISOString() };
+        const sessionPath = this.getSessionPath(sessionId);
+        const lines = [
+            JSON.stringify(updatedSession),
+            ...entities.map(e => serializeEntity(e)),
+            ...relations.map(r => serializeRelation(r))
+        ];
+        await fs.writeFile(sessionPath, lines.join('\n') + '\n');
+    }
+    async updateEntity(sessionId, entityName, updates) {
+        const { session, entities, relations } = await this.loadSession(sessionId);
+        const entityIndex = entities.findIndex(e => e.name === entityName);
+        if (entityIndex === -1) {
+            throw new Error(`Entity ${entityName} not found in session ${sessionId}`);
+        }
+        entities[entityIndex] = { ...entities[entityIndex], ...updates };
+        if (entities[entityIndex].metadata) {
+            entities[entityIndex].metadata.updatedAt = new Date().toISOString();
+        }
+        const sessionPath = this.getSessionPath(sessionId);
+        const lines = [
+            JSON.stringify(session),
+            ...entities.map(e => serializeEntity(e)),
+            ...relations.map(r => serializeRelation(r))
+        ];
+        await fs.writeFile(sessionPath, lines.join('\n') + '\n');
+    }
+    async listSessions() {
+        try {
+            await this.ensureBaseDir();
+            const files = await fs.readdir(this.baseDir);
+            const sessions = [];
+            for (const file of files) {
+                if (file.endsWith('.jsonl')) {
+                    try {
+                        const sessionId = file.replace('.jsonl', '');
+                        const { session } = await this.loadSession(sessionId);
+                        sessions.push(session);
+                    }
+                    catch {
+                        // Skip corrupted files
+                    }
+                }
+            }
+            return sessions.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+        }
+        catch {
+            return [];
+        }
+    }
+    async deleteSession(sessionId) {
+        const sessionPath = this.getSessionPath(sessionId);
+        await fs.unlink(sessionPath);
+    }
+    async getSessionFilePath(sessionId) {
+        return this.getSessionPath(sessionId);
+    }
+    // =========================================================================
+    // PDE Decomposition File Access (.pde/ directory)
+    // =========================================================================
+    async listPdeDecompositions(workdir) {
+        const pdeDir = path.join(workdir || process.cwd(), '.pde');
+        try {
+            const entries = await fs.readdir(pdeDir);
+            const results = [];
+            for (const entry of entries) {
+                if (!entry.endsWith('.json'))
+                    continue;
+                try {
+                    const filePath = path.join(pdeDir, entry);
+                    const data = await fs.readFile(filePath, 'utf-8');
+                    const stored = JSON.parse(data);
+                    if (stored.id && stored.result) {
+                        results.push({
+                            id: stored.id,
+                            timestamp: stored.timestamp,
+                            prompt: stored.prompt,
+                        });
+                    }
+                }
+                catch {
+                    // Skip invalid files
+                }
+            }
+            return results.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+        }
+        catch {
+            return [];
+        }
+    }
+    async loadPdeDecomposition(id, workdir) {
+        const pdeDir = path.join(workdir || process.cwd(), '.pde');
+        // Try direct {id}.json file first
+        const directPath = path.join(pdeDir, `${id}.json`);
+        try {
+            const data = await fs.readFile(directPath, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            // Not found as direct file — scan for matching id
+        }
+        // Scan directory for a .json file whose parsed id matches
+        try {
+            const entries = await fs.readdir(pdeDir);
+            for (const entry of entries) {
+                if (!entry.endsWith('.json'))
+                    continue;
+                try {
+                    const filePath = path.join(pdeDir, entry);
+                    const data = await fs.readFile(filePath, 'utf-8');
+                    const parsed = JSON.parse(data);
+                    if (parsed.id === id)
+                        return parsed;
+                }
+                catch {
+                    // Skip invalid
+                }
+            }
+        }
+        catch {
+            // Directory not found
+        }
+        return null;
+    }
+}
+export const sessionManager = new SessionManager();
+//# sourceMappingURL=session-manager.js.map

package/dist/src/pde/stc-mapper.d.ts

@@ -0,0 +1,26 @@
+/**
+ * STC Mapper — Transforms mcp-pde DecompositionResult into Entity[]/Relation[]
+ * Ported from coaia-pde/src/stc-mapper.ts
+ */
+import type { DecompositionResult, Entity, Relation } from '../types.js';
+export declare class StcMapper {
+    /**
+     * Core method: Transform a DecompositionResult into Entity[]/Relation[].
+     */
+    mapDecompositionToChart(result: DecompositionResult, originalPrompt: string, options?: {
+        pdeId?: string;
+        dueDate?: string;
+    }): {
+        entities: Entity[];
+        relations: Relation[];
+        chartId: string;
+    };
+    private addDependencyRelation;
+    private formatDesiredOutcome;
+    private formatCurrentReality;
+    private mapDirectionsToFourDirections;
+    private calculateDueDate;
+    private distributeActionDates;
+}
+export declare const stcMapper: StcMapper;
+//# sourceMappingURL=stc-mapper.d.ts.map

package/dist/src/pde/stc-mapper.js

@@ -0,0 +1,234 @@
+/**
+ * STC Mapper — Transforms mcp-pde DecompositionResult into Entity[]/Relation[]
+ * Ported from coaia-pde/src/stc-mapper.ts
+ */
+import { v4 as uuidv4 } from 'uuid';
+import { URGENCY_DAYS } from '../types.js';
+export class StcMapper {
+    /**
+     * Core method: Transform a DecompositionResult into Entity[]/Relation[].
+     */
+    mapDecompositionToChart(result, originalPrompt, options) {
+        const chartId = `chart_${uuidv4().substring(0, 8)}`;
+        const now = new Date().toISOString();
+        const dueDate = options?.dueDate || this.calculateDueDate(result.primary.urgency);
+        const fourDirections = this.mapDirectionsToFourDirections(result.directions);
+        const entities = [];
+        const relations = [];
+        // 1. Master chart entity
+        entities.push({
+            name: `${chartId}_chart`,
+            entityType: 'structural_tension_chart',
+            observations: [`Master chart for: ${result.primary.action} ${result.primary.target}`],
+            metadata: {
+                chartId,
+                dueDate,
+                level: 0,
+                phase: 'germination',
+                createdAt: now,
+                updatedAt: now,
+                pdeId: options?.pdeId,
+                fourDirections,
+            }
+        });
+        // 2. Desired outcome entity
+        const desiredOutcomeObs = [this.formatDesiredOutcome(result.primary)];
+        for (const a of result.outputs.artifacts)
+            desiredOutcomeObs.push(`Artifact: ${a}`);
+        for (const u of result.outputs.updates)
+            desiredOutcomeObs.push(`Update: ${u}`);
+        for (const c of result.outputs.communications)
+            desiredOutcomeObs.push(`Communication: ${c}`);
+        entities.push({
+            name: `${chartId}_desired_outcome`,
+            entityType: 'desired_outcome',
+            observations: desiredOutcomeObs,
+            metadata: {
+                chartId,
+                confidence: result.primary.confidence,
+                createdAt: now,
+                updatedAt: now,
+            }
+        });
+        // 3. Current reality entity
+        entities.push({
+            name: `${chartId}_current_reality`,
+            entityType: 'current_reality',
+            observations: this.formatCurrentReality(result.context, result.ambiguities),
+            metadata: {
+                chartId,
+                createdAt: now,
+                updatedAt: now,
+            }
+        });
+        // 4. Action step entities from secondary[] + actionStack[]
+        const totalActionCount = result.secondary.length + result.actionStack.length;
+        const actionDueDates = this.distributeActionDates(new Date(), new Date(dueDate), totalActionCount);
+        let actionIndex = 0;
+        for (const sec of result.secondary) {
+            const actionName = `${chartId}_action_${++actionIndex}`;
+            entities.push({
+                name: actionName,
+                entityType: 'action_step',
+                observations: [`${sec.action} ${sec.target}`],
+                metadata: {
+                    chartId,
+                    dueDate: actionDueDates[actionIndex - 1]?.toISOString(),
+                    completionStatus: false,
+                    level: 1,
+                    parentChart: chartId,
+                    implicit: sec.implicit,
+                    confidence: sec.confidence,
+                    createdAt: now,
+                    updatedAt: now,
+                }
+            });
+            relations.push({
+                from: `${chartId}_chart`,
+                to: actionName,
+                relationType: 'has_action_step',
+                metadata: { createdAt: now }
+            });
+            relations.push({
+                from: actionName,
+                to: `${chartId}_desired_outcome`,
+                relationType: 'advances_toward',
+                metadata: { createdAt: now }
+            });
+            if (sec.dependency) {
+                this.addDependencyRelation(entities, relations, actionName, sec.dependency, now);
+            }
+        }
+        for (const item of result.actionStack) {
+            const actionName = `${chartId}_action_${++actionIndex}`;
+            entities.push({
+                name: actionName,
+                entityType: 'action_step',
+                observations: [item.text],
+                metadata: {
+                    chartId,
+                    dueDate: actionDueDates[actionIndex - 1]?.toISOString(),
+                    completionStatus: item.completed || false,
+                    level: 1,
+                    parentChart: chartId,
+                    direction: item.direction,
+                    createdAt: now,
+                    updatedAt: now,
+                }
+            });
+            relations.push({
+                from: `${chartId}_chart`,
+                to: actionName,
+                relationType: 'has_action_step',
+                metadata: { createdAt: now }
+            });
+            relations.push({
+                from: actionName,
+                to: `${chartId}_desired_outcome`,
+                relationType: 'advances_toward',
+                metadata: { createdAt: now }
+            });
+            if (item.dependency) {
+                this.addDependencyRelation(entities, relations, actionName, item.dependency, now);
+            }
+        }
+        // 5. Structural relations
+        relations.push({
+            from: `${chartId}_chart`,
+            to: `${chartId}_desired_outcome`,
+            relationType: 'has_desired_outcome',
+            metadata: { createdAt: now }
+        }, {
+            from: `${chartId}_chart`,
+            to: `${chartId}_current_reality`,
+            relationType: 'has_current_reality',
+            metadata: { createdAt: now }
+        }, {
+            from: `${chartId}_current_reality`,
+            to: `${chartId}_desired_outcome`,
+            relationType: 'creates_tension_with',
+            metadata: { createdAt: now }
+        });
+        return { entities, relations, chartId };
+    }
+    addDependencyRelation(entities, relations, fromName, dependency, now) {
+        const depEntity = entities.find(e => e.entityType === 'action_step' && e.observations[0]?.includes(dependency));
+        if (depEntity) {
+            relations.push({
+                from: fromName,
+                to: depEntity.name,
+                relationType: 'depends_on',
+                metadata: { createdAt: now, context: dependency }
+            });
+        }
+    }
+    formatDesiredOutcome(primary) {
+        const { action, target } = primary;
+        const resultPhrases = {
+            create: `Completed ${target}`,
+            build: `Functional ${target}`,
+            implement: `Working ${target}`,
+            write: `Finished ${target}`,
+            design: `Complete design for ${target}`,
+            develop: `Deployed ${target}`,
+            analyze: `Clear understanding of ${target}`,
+            integrate: `Fully integrated ${target}`,
+            test: `Validated ${target}`,
+            fix: `Resolved ${target}`,
+            refactor: `Refactored ${target}`,
+        };
+        for (const [verb, phrase] of Object.entries(resultPhrases)) {
+            if (action.startsWith(verb)) {
+                return phrase;
+            }
+        }
+        return `Completed: ${action} ${target}`;
+    }
+    formatCurrentReality(context, ambiguities) {
+        const observations = [];
+        if (context.files_needed.length > 0) {
+            observations.push(`Files to reference: ${context.files_needed.join(', ')}`);
+        }
+        if (context.tools_required.length > 0) {
+            observations.push(`Tools available: ${context.tools_required.join(', ')}`);
+        }
+        for (const assumption of context.assumptions) {
+            observations.push(`Assumption: ${assumption}`);
+        }
+        for (const ambiguity of ambiguities) {
+            observations.push(`⚠️ Ambiguity: ${ambiguity.text} — Suggestion: ${ambiguity.suggestion}`);
+        }
+        if (observations.length === 0) {
+            observations.push('Starting point: No prior work on this goal');
+        }
+        return observations;
+    }
+    mapDirectionsToFourDirections(directions) {
+        const join = (items) => items.length > 0 ? items.map(i => i.text).join('; ') : null;
+        return {
+            north_vision: join(directions.north || []),
+            east_intention: join(directions.east || []),
+            south_emotion: join(directions.south || []),
+            west_introspection: join(directions.west || []),
+        };
+    }
+    calculateDueDate(urgency) {
+        const days = URGENCY_DAYS[urgency] || URGENCY_DAYS['session'];
+        const date = new Date();
+        date.setDate(date.getDate() + days);
+        return date.toISOString();
+    }
+    distributeActionDates(start, end, count) {
+        if (count === 0)
+            return [];
+        const totalTime = end.getTime() - start.getTime();
+        const interval = totalTime / (count + 1);
+        const dates = [];
+        for (let i = 1; i <= count; i++) {
+            dates.push(new Date(start.getTime() + interval * i));
+        }
+        return dates;
+    }
+}
+export const stcMapper = new StcMapper();
+//# sourceMappingURL=stc-mapper.js.map

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

@@ -0,0 +1,2 @@
+export { TemplateLoader, TemplateRenderer, MobileTemplateEngine, } from './template-engine.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/pipeline/index.js

@@ -0,0 +1,3 @@
+// coaiajs/src/pipeline/index.ts — Barrel export
+export { TemplateLoader, TemplateRenderer, MobileTemplateEngine, } from './template-engine.js';
+//# sourceMappingURL=index.js.map

package/dist/src/pipeline/template-engine.d.ts

@@ -0,0 +1,20 @@
+import type { PipelineTemplate, PipelineStep } from '../types.js';
+export declare class MobileTemplateEngine {
+    renderString(text: string, variables: Record<string, string>): string;
+    renderDict(data: Record<string, unknown>, variables: Record<string, string>): Record<string, unknown>;
+    private renderList;
+}
+export declare class TemplateLoader {
+    private searchPaths;
+    constructor();
+    private getSearchPaths;
+    listTemplates(includePath?: boolean): Array<Record<string, unknown>>;
+    loadTemplate(name: string): PipelineTemplate | null;
+    saveTemplate(template: PipelineTemplate, location?: 'user' | 'project'): void;
+}
+export declare class TemplateRenderer {
+    private engine;
+    renderTemplate(template: PipelineTemplate, variables: Record<string, string>): PipelineStep[];
+    renderWithJudgeIntegration(template: PipelineTemplate, variables: Record<string, string>, enableJudge?: boolean): PipelineStep[];
+}
+//# sourceMappingURL=template-engine.d.ts.map