coaia-visualizer 1.4.2 → 1.5.0

package/lib/chart-editor.ts

@@ -1,11 +1,18 @@
 // lib/chart-editor.ts - Chart editing logic
 
-import type { Chart, EntityRecord, RelationRecord, ParsedData, JSONLRecord } from './types'
+import type { EntityRecord, RelationRecord, ParsedData } from "./types"
 
 export interface ChartUpdate {
-  type: 'update_desired_outcome' | 'update_current_reality' | 'add_observation' | 
-        'update_action' | 'add_action' | 'delete_action' | 'toggle_action_completion' |
-        'update_due_date' | 'update_action_due_date'
+  type:
+  | "update_desired_outcome"
+  | "update_current_reality"
+  | "add_observation"
+  | "update_action"
+  | "add_action"
+  | "delete_action"
+  | "toggle_action_completion"
+  | "update_due_date"
+  | "update_action_due_date"
   chartId: string
   data: any
 }
@@ -23,7 +30,7 @@ export class ChartEditor {
   updateDesiredOutcome(chartId: string, newText: string): void {
     const desiredOutcomeName = `${chartId}_desired_outcome`
     const entity = this.entities.get(desiredOutcomeName)
-    
+
     if (entity) {
       entity.observations = [newText]
       entity.metadata.updatedAt = new Date().toISOString()
@@ -34,7 +41,7 @@ export class ChartEditor {
   addCurrentRealityObservation(chartId: string, observation: string): void {
     const currentRealityName = `${chartId}_current_reality`
     const entity = this.entities.get(currentRealityName)
-    
+
     if (entity) {
       entity.observations.push(observation)
       entity.metadata.updatedAt = new Date().toISOString()
@@ -45,12 +52,12 @@ export class ChartEditor {
   updateCurrentReality(chartId: string, newObservations: string[]): void {
     const currentRealityName = `${chartId}_current_reality`
     const entity = this.entities.get(currentRealityName)
-    
+
     if (!entity) {
       throw new Error(`Chart ${chartId} current reality not found`)
     }
 
-    const uniqueObservations = newObservations.filter(obs => !entity.observations.includes(obs))
+    const uniqueObservations = newObservations.filter((obs) => !entity.observations.includes(obs))
     entity.observations.push(...uniqueObservations)
     entity.metadata.updatedAt = new Date().toISOString()
     this.entities.set(currentRealityName, entity)
@@ -59,7 +66,7 @@ export class ChartEditor {
   updateCurrentRealityObservation(chartId: string, index: number, newText: string): void {
     const currentRealityName = `${chartId}_current_reality`
     const entity = this.entities.get(currentRealityName)
-    
+
     if (entity && entity.observations[index] !== undefined) {
       entity.observations[index] = newText
       entity.metadata.updatedAt = new Date().toISOString()
@@ -70,7 +77,7 @@ export class ChartEditor {
   deleteCurrentRealityObservation(chartId: string, index: number): void {
     const currentRealityName = `${chartId}_current_reality`
     const entity = this.entities.get(currentRealityName)
-    
+
     if (entity) {
       entity.observations.splice(index, 1)
       entity.metadata.updatedAt = new Date().toISOString()
@@ -82,10 +89,10 @@ export class ChartEditor {
     parentChartId: string,
     actionStepTitle: string,
     currentReality: string,
-    dueDate?: string
+    dueDate?: string,
   ): { chartId: string; actionStepName: string } {
     const parentChart = this.entities.get(parentChartId)
-    if (!parentChart || parentChart.entityType !== 'structural_tension_chart') {
+    if (!parentChart || parentChart.entityType !== "structural_tension_chart") {
       throw new Error(`Parent chart ${parentChartId} not found`)
     }
 
@@ -97,7 +104,9 @@ export class ChartEditor {
     }
 
     if (!currentReality) {
-      throw new Error(`Current reality required for action step "${actionStepTitle}". Provide honest assessment of actual current state relative to this action step.`)
+      throw new Error(
+        `Current reality required for action step "${actionStepTitle}". Provide honest assessment of actual current state relative to this action step.`,
+      )
     }
 
     let telescopedDueDate = dueDate
@@ -108,88 +117,91 @@ export class ChartEditor {
       telescopedDueDate = midpoint.toISOString()
     }
 
-    const existingCharts = Array.from(this.entities.values())
-      .filter(e => e.entityType === 'structural_tension_chart')
+    const existingCharts = Array.from(this.entities.values()).filter((e) => e.entityType === "structural_tension_chart")
     const maxId = existingCharts.reduce((max, e) => {
-      const id = parseInt(e.metadata?.chartId?.replace('chart_', '') || '0')
+      const id = Number.parseInt(e.metadata?.chartId?.replace("chart_", "") || "0")
       return Math.max(max, id)
     }, 0)
     const newChartId = `chart_${maxId + 1}`
     const timestamp = new Date().toISOString()
 
-    this.entities.set(newChartId, {
-      type: 'entity',
-      name: newChartId,
-      entityType: 'structural_tension_chart',
+    // Extract chart ID from parentChartId (entity name) for parentChart reference
+    const parentChartId_normalized = parentChartId.replace("_chart", "")
+
+    const chartEntityName = `${newChartId}_chart`
+    this.entities.set(chartEntityName, {
+      type: "entity",
+      name: chartEntityName,
+      entityType: "structural_tension_chart",
       observations: [`Telescoped chart for: ${actionStepTitle}`],
       metadata: {
         chartId: newChartId,
         level: parentLevel + 1,
-        parentChart: parentChartId,
+        parentChart: parentChartId_normalized,
         dueDate: telescopedDueDate,
         completionStatus: false,
         createdAt: timestamp,
-        updatedAt: timestamp
-      }
+        updatedAt: timestamp,
+      },
     })
 
     const desiredOutcomeName = `${newChartId}_desired_outcome`
     this.entities.set(desiredOutcomeName, {
-      type: 'entity',
+      type: "entity",
       name: desiredOutcomeName,
-      entityType: 'desired_outcome',
+      entityType: "desired_outcome",
       observations: [actionStepTitle],
       metadata: {
         chartId: newChartId,
         createdAt: timestamp,
-        updatedAt: timestamp
-      }
+        updatedAt: timestamp,
+      },
     })
 
     const currentRealityName = `${newChartId}_current_reality`
     this.entities.set(currentRealityName, {
-      type: 'entity',
+      type: "entity",
       name: currentRealityName,
-      entityType: 'current_reality',
+      entityType: "current_reality",
       observations: [currentReality],
       metadata: {
         chartId: newChartId,
         createdAt: timestamp,
-        updatedAt: timestamp
-      }
+        updatedAt: timestamp,
+      },
     })
 
     this.relations.push({
-      type: 'relation',
+      type: "relation",
       from: newChartId,
       to: desiredOutcomeName,
-      relationType: 'contains',
-      metadata: { createdAt: timestamp }
+      relationType: "contains",
+      metadata: { createdAt: timestamp },
     })
 
     this.relations.push({
-      type: 'relation',
+      type: "relation",
       from: newChartId,
       to: currentRealityName,
-      relationType: 'contains',
-      metadata: { createdAt: timestamp }
+      relationType: "contains",
+      metadata: { createdAt: timestamp },
     })
 
     this.relations.push({
-      type: 'relation',
+      type: "relation",
       from: currentRealityName,
       to: desiredOutcomeName,
-      relationType: 'creates_tension_with',
-      metadata: { createdAt: timestamp }
+      relationType: "creates_tension_with",
+      metadata: { createdAt: timestamp },
     })
 
     const parentDesiredOutcome = `${parentChartId}_desired_outcome`
     this.relations.push({
-      type: 'relation',
+      type: "relation",
       from: desiredOutcomeName,
       to: parentDesiredOutcome,
-      relationType: 'advances_toward',
-      metadata: { createdAt: timestamp }
+      relationType: "advances_toward",
+      metadata: { createdAt: timestamp },
     })
 
     return { chartId: newChartId, actionStepName: desiredOutcomeName }
@@ -197,8 +209,8 @@ export class ChartEditor {
 
   updateActionStep(chartId: string, actionName: string, description: string): void {
     const entity = this.entities.get(actionName)
-    
-    if (entity && (entity.entityType === 'action_step' || entity.entityType === 'desired_outcome')) {
+
+    if (entity && (entity.entityType === "action_step" || entity.entityType === "desired_outcome")) {
       entity.observations = [description]
       entity.metadata.updatedAt = new Date().toISOString()
       this.entities.set(actionName, entity)
@@ -207,7 +219,7 @@ export class ChartEditor {
 
   markActionStepComplete(actionStepName: string): void {
     const actionStep = this.entities.get(actionStepName)
-    if (!actionStep || (actionStep.entityType !== 'action_step' && actionStep.entityType !== 'desired_outcome')) {
+    if (!actionStep || (actionStep.entityType !== "action_step" && actionStep.entityType !== "desired_outcome")) {
       throw new Error(`Action step ${actionStepName} not found`)
     }
 
@@ -233,7 +245,7 @@ export class ChartEditor {
     if (parentChartId) {
       const parentCurrentRealityName = `${parentChartId}_current_reality`
       const parentCurrentReality = this.entities.get(parentCurrentRealityName)
-      
+
       if (parentCurrentReality) {
         const completionMessage = `Completed: ${actionStep.observations[0]}`
         if (!parentCurrentReality.observations.includes(completionMessage)) {
@@ -247,14 +259,10 @@ export class ChartEditor {
     }
   }
 
-  updateActionProgress(
-    actionStepName: string,
-    progressObservation: string,
-    updateCurrentReality?: boolean
-  ): void {
+  updateActionProgress(actionStepName: string, progressObservation: string, updateCurrentReality?: boolean): void {
     const actionStep = this.entities.get(actionStepName)
-    
-    if (!actionStep || (actionStep.entityType !== 'action_step' && actionStep.entityType !== 'desired_outcome')) {
+
+    if (!actionStep || (actionStep.entityType !== "action_step" && actionStep.entityType !== "desired_outcome")) {
       throw new Error(`Action step ${actionStepName} not found`)
     }
 
@@ -267,11 +275,11 @@ export class ChartEditor {
     if (updateCurrentReality && actionStep.metadata?.chartId) {
       const chartEntity = this.entities.get(actionStep.metadata.chartId)
       const parentChartId = chartEntity?.metadata?.parentChart
-      
+
       if (parentChartId) {
         const parentCurrentRealityName = `${parentChartId}_current_reality`
         const parentCurrentReality = this.entities.get(parentCurrentRealityName)
-        
+
         if (parentCurrentReality) {
           const progressMessage = `Progress on ${actionStep.observations[0]}: ${progressObservation}`
           if (!parentCurrentReality.observations.includes(progressMessage)) {
@@ -288,8 +296,8 @@ export class ChartEditor {
 
   toggleActionCompletion(actionName: string): void {
     const entity = this.entities.get(actionName)
-    
-    if (entity && (entity.entityType === 'action_step' || entity.entityType === 'desired_outcome')) {
+
+    if (entity && (entity.entityType === "action_step" || entity.entityType === "desired_outcome")) {
       entity.metadata.completionStatus = !entity.metadata.completionStatus
       entity.metadata.updatedAt = new Date().toISOString()
       if (entity.metadata.completionStatus) {
@@ -303,8 +311,8 @@ export class ChartEditor {
 
   updateActionDueDate(actionName: string, dueDate: string | null): void {
     const entity = this.entities.get(actionName)
-    
-    if (entity && entity.entityType === 'action_step') {
+
+    if (entity && entity.entityType === "action_step") {
       if (dueDate) {
         entity.metadata.dueDate = dueDate
       } else {
@@ -320,14 +328,143 @@ export class ChartEditor {
     this.entities.delete(actionName)
 
     // Remove related relations
-    this.relations = this.relations.filter(r => r.from !== actionName && r.to !== actionName)
+    this.relations = this.relations.filter((r) => r.from !== actionName && r.to !== actionName)
+  }
+
+  createTelescopedChartFromAction(parentChartId: string, actionName: string): string {
+    const actionEntity = this.entities.get(actionName)
+    if (!actionEntity || (actionEntity.entityType !== "action_step" && actionEntity.entityType !== "desired_outcome")) {
+      throw new Error(`Action ${actionName} not found`)
+    }
+
+    const parentChart = this.entities.get(parentChartId)
+    if (!parentChart || parentChart.entityType !== "structural_tension_chart") {
+      throw new Error(`Parent chart ${parentChartId} not found`)
+    }
+
+    const actionDescription = actionEntity.observations[0] || "Untitled Action"
+    const parentLevel = parentChart.metadata?.level || 0
+    const parentDueDate = parentChart.metadata?.dueDate
+
+    if (!parentDueDate) {
+      throw new Error(`Parent chart ${parentChartId} has no due date`)
+    }
+
+    // Calculate telescoped due date (midpoint between now and parent due date)
+    const now = new Date()
+    const parentEnd = new Date(parentDueDate)
+    const midpoint = new Date(now.getTime() + (parentEnd.getTime() - now.getTime()) / 2)
+    const telescopedDueDate = midpoint.toISOString()
+
+    // Generate new chart ID
+    const existingCharts = Array.from(this.entities.values()).filter((e) => e.entityType === "structural_tension_chart")
+    const maxId = existingCharts.reduce((max, e) => {
+      const id = Number.parseInt(e.metadata?.chartId?.replace("chart_", "") || "0")
+      return Math.max(max, id)
+    }, 0)
+    const newChartId = `chart_${maxId + 1}`
+    const timestamp = new Date().toISOString()
+
+    // Extract chart ID from parentChartId (entity name) for parentChart reference
+    const parentChartId_normalized = parentChartId.replace("_chart", "")
+
+    // Create new chart
+    const chartEntityName = `${newChartId}_chart`
+    this.entities.set(chartEntityName, {
+      type: "entity",
+      name: chartEntityName,
+      entityType: "structural_tension_chart",
+      observations: [`Telescoped chart for: ${actionDescription}`],
+      metadata: {
+        chartId: newChartId,
+        level: parentLevel + 1,
+        parentChart: parentChartId_normalized,
+        dueDate: telescopedDueDate,
+        completionStatus: false,
+        createdAt: timestamp,
+        updatedAt: timestamp,
+      },
+    })
+
+    // Create desired outcome (use action description)
+    const desiredOutcomeName = `${newChartId}_desired_outcome`
+    this.entities.set(desiredOutcomeName, {
+      type: "entity",
+      name: desiredOutcomeName,
+      entityType: "desired_outcome",
+      observations: [actionDescription],
+      metadata: {
+        chartId: newChartId,
+        createdAt: timestamp,
+        updatedAt: timestamp,
+      },
+    })
+
+    // Create current reality (needs initial observation)
+    const currentRealityName = `${newChartId}_current_reality`
+    this.entities.set(currentRealityName, {
+      type: "entity",
+      name: currentRealityName,
+      entityType: "current_reality",
+      observations: ["Starting work on this action step"],
+      metadata: {
+        chartId: newChartId,
+        createdAt: timestamp,
+        updatedAt: timestamp,
+      },
+    })
+
+    // Create relations
+    this.relations.push({
+      type: "relation",
+      from: newChartId,
+      to: desiredOutcomeName,
+      relationType: "contains",
+      metadata: { createdAt: timestamp },
+    })
+
+    this.relations.push({
+      type: "relation",
+      from: newChartId,
+      to: currentRealityName,
+      relationType: "contains",
+      metadata: { createdAt: timestamp },
+    })
+
+    this.relations.push({
+      type: "relation",
+      from: currentRealityName,
+      to: desiredOutcomeName,
+      relationType: "creates_tension_with",
+      metadata: { createdAt: timestamp },
+    })
+
+    // Link new chart's desired outcome to parent desired outcome
+    const parentDesiredOutcome = `${parentChartId}_desired_outcome`
+    this.relations.push({
+      type: "relation",
+      from: desiredOutcomeName,
+      to: parentDesiredOutcome,
+      relationType: "advances_toward",
+      metadata: { createdAt: timestamp },
+    })
+
+    // Mark the original action as a telescoped chart
+    if (actionEntity.metadata) {
+      actionEntity.metadata.isTelescopedChart = true
+      actionEntity.metadata.telescopedChartId = newChartId
+      actionEntity.metadata.updatedAt = timestamp
+      this.entities.set(actionName, actionEntity)
+    }
+
+    return newChartId
   }
 
   updateChartDueDate(chartId: string, dueDate: string | null): void {
     const chartName = chartId
     const entity = this.entities.get(chartName)
-    
-    if (entity && entity.entityType === 'structural_tension_chart') {
+
+    if (entity && entity.entityType === "structural_tension_chart") {
       if (dueDate) {
         entity.metadata.dueDate = dueDate
       } else {
@@ -351,13 +488,89 @@ export class ChartEditor {
       lines.push(JSON.stringify(relation))
     }
 
-    return lines.join('\n') + '\n'
+    return lines.join("\n") + "\n"
   }
 
   getUpdatedData(): ParsedData {
-    // Re-parse and organize the updated data
-    const { parseJSONL, organizeData } = require('./jsonl-parser')
-    const records = this.exportToJSONL().split('\n').filter(l => l.trim()).map(l => JSON.parse(l))
-    return organizeData(records)
+    const chartsMap = new Map<string, any>()
+
+    // Organize entities into charts
+    for (const [name, entity] of this.entities.entries()) {
+      if (entity.entityType === "structural_tension_chart") {
+        const chartId = entity.metadata?.chartId || name
+        chartsMap.set(chartId, {
+          id: chartId,
+          chartEntity: entity,
+          desiredOutcome: undefined,
+          currentReality: undefined,
+          actions: [],
+          narrativeBeats: [],
+          subCharts: [],
+          level: entity.metadata?.level || 0,
+          parentChart: entity.metadata?.parentChart,
+          relations: [],
+        })
+      }
+    }
+
+    // Populate chart components
+    for (const [name, entity] of this.entities.entries()) {
+      const chartId = entity.metadata?.chartId
+      if (!chartId) continue
+
+      const chart = chartsMap.get(chartId)
+      if (!chart) continue
+
+      switch (entity.entityType) {
+        case "desired_outcome":
+          chart.desiredOutcome = entity
+          break
+        case "current_reality":
+          chart.currentReality = entity
+          break
+        case "action_step":
+          chart.actions.push(entity)
+          break
+        case "narrative_beat":
+          chart.narrativeBeats.push(entity)
+          break
+      }
+    }
+
+    // Add relevant relations to each chart
+    for (const relation of this.relations) {
+      for (const [chartId, chart] of chartsMap.entries()) {
+        if (
+          relation.from.startsWith(chartId) ||
+          relation.to.startsWith(chartId) ||
+          relation.from === chartId ||
+          relation.to === chartId
+        ) {
+          chart.relations.push(relation)
+        }
+      }
+    }
+
+    const chartsArray: any[] = Array.from(chartsMap.values())
+
+    // Build hierarchy - add subcharts to parent charts
+    for (const chart of chartsArray) {
+      const parentChartId = chart.parentChart
+      if (parentChartId) {
+        const parentChart = chartsArray.find((c) => c.id === parentChartId)
+        if (parentChart) {
+          parentChart.subCharts.push(chart)
+        }
+      }
+    }
+
+    const rootCharts = chartsArray.filter((c) => !c.parentChart)
+
+    return {
+      entities: this.entities,
+      relations: this.relations,
+      charts: chartsArray,
+      rootCharts: rootCharts,
+    }
   }
 }

package/mcp/Dockerfile

@@ -0,0 +1,21 @@
+FROM node:20-alpine
+
+WORKDIR /app
+
+# Copy package files
+COPY package.json package-lock.json* ./
+
+# Install dependencies
+RUN npm install
+
+# Copy source and build
+COPY . .
+RUN npm run build
+
+# Create data directory
+RUN mkdir -p /data
+
+ENV NODE_ENV=production
+
+# MCP servers use stdio for communication
+CMD ["node", "dist/index.js"]

package/mcp/README.md

@@ -123,22 +123,41 @@ Update a chart's desired outcome, current reality, or due date.
 \`\`\`
 
 ### add_action_step
-Add a new action step to a chart.
+Add a new action step to a chart as a telescoped structural tension chart.
 
 **Parameters:**
-- `chartId` (required): Chart ID
-- `description` (required): Action description
-- `dueDate` (optional): ISO date string
+- `parentChartId` (required): The parent chart ID
+- `actionStepTitle` (required): Action step title (becomes desired outcome)
+- `currentReality` (required): Honest assessment of actual current state relative to this action step
+- `dueDate` (optional): ISO date string (auto-distributed if not provided)
 
 **Example:**
 \`\`\`json
 {
-  "chartId": "chart_1",
-  "description": "Write API documentation",
+  "parentChartId": "chart_1",
+  "actionStepTitle": "Write API documentation",
+  "currentReality": "No documentation exists yet",
   "dueDate": "2026-01-15"
 }
 \`\`\`
 
+### create_telescoped_chart
+Create a telescoped (drill-down) chart from an EXISTING action step. This converts an existing action into a detailed sub-chart for deeper work breakdown.
+
+**Parameters:**
+- `chartId` (required): The parent chart ID containing the action
+- `actionName` (required): The action entity name to telescope (e.g., "chart_1_action_1")
+
+**Example:**
+\`\`\`json
+{
+  "chartId": "chart_1",
+  "actionName": "chart_1_action_1"
+}
+\`\`\`
+
+**Note:** This is different from `add_action_step`. Use `add_action_step` when creating a NEW action that should be a telescoped chart. Use `create_telescoped_chart` to telescope an EXISTING action into a sub-chart.
+
 ### update_action_step
 Update an existing action step.
 

package/mcp/src/api-client.ts

@@ -51,7 +51,7 @@ export class CoaiaVisualizerClient {
 
   private async fetchJson<T>(path: string, options: RequestInit = {}): Promise<T> {
     const response = await this.fetch(path, options)
-    
+
     if (!response.ok) {
       const error: any = await response.json().catch(() => ({ error: 'Unknown error' }))
       throw new Error(`API Error (${response.status}): ${error.error || error.message || 'Unknown error'}`)
@@ -70,7 +70,7 @@ export class CoaiaVisualizerClient {
     const params = new URLSearchParams()
     if (options?.level !== undefined) params.set('level', options.level.toString())
     if (options?.rootOnly) params.set('rootOnly', 'true')
-    
+
     const query = params.toString()
     return this.fetchJson(`/api/charts${query ? `?${query}` : ''}`)
   }
@@ -121,6 +121,18 @@ export class CoaiaVisualizerClient {
     })
   }
 
+  /**
+   * Create telescoped chart from existing action
+   */
+  async createTelescopedChart(chartId: string, actionName: string): Promise<{ chart: Chart; updates: string[]; message: string; backup: string }> {
+    return this.fetchJson(`/api/charts/${chartId}`, {
+      method: 'POST',
+      body: JSON.stringify({
+        createTelescopedChart: { actionName },
+      }),
+    })
+  }
+
   /**
    * Delete a chart
    */
@@ -144,7 +156,7 @@ export class CoaiaVisualizerClient {
     if (query.level !== undefined) params.set('level', query.level.toString())
     if (query.completed !== undefined) params.set('completed', query.completed.toString())
     if (query.hasActions !== undefined) params.set('hasActions', query.hasActions.toString())
-    
+
     return this.fetchJson(`/api/charts/search?${params.toString()}`)
   }