coaia-visualizer 1.6.3 → 1.6.5

package/lib/github-provenance.ts

@@ -0,0 +1,316 @@
+import type { EntityRecord, RelationRecord } from "./types.ts"
+
+export const GITHUB_SYNC_STATES = ["synced", "diverged", "conflict", "project-only", "chart-only"] as const
+
+export type GithubSyncState = (typeof GITHUB_SYNC_STATES)[number]
+
+export interface GithubIssueRef {
+  owner: string
+  repo: string
+  number: number
+  nodeId?: string
+  url?: string
+}
+
+export interface GithubProjectItemRef {
+  projectOwner?: string
+  projectNumber?: number
+  projectTitle?: string
+  itemId?: string
+  projectId?: string
+  url?: string
+  fields?: Record<string, unknown>
+  fieldValues?: Record<string, unknown>
+  projectFields?: Record<string, unknown>
+  [key: string]: unknown
+}
+
+export interface GithubSourceProvenance {
+  system?: string
+  toolName?: string
+  sessionId?: string
+  createdAt?: string
+  version?: string
+  [key: string]: unknown
+}
+
+export interface GithubEntityProvenance {
+  issue?: GithubIssueRef
+  projectItems: GithubProjectItemRef[]
+  syncState?: GithubSyncState
+  lastSyncedAt?: string
+  source?: GithubSourceProvenance
+  hasGithubMetadata: boolean
+}
+
+export interface GithubProjectFieldEntry {
+  key: string
+  label: string
+  value: string
+}
+
+export const GITHUB_PROJECT_FIELD_KEYS = [
+  "goal",
+  "current_reality",
+  "observations",
+  "question",
+  "Status",
+  "phase",
+  "session_id",
+  "four_dir_east",
+  "four_dir_south",
+  "four_dir_west",
+  "four_dir_north",
+  "relational_assessed",
+  "relational_principles",
+] as const
+
+export const GITHUB_BRIDGE_RELATION_TYPES = ["synced_to_github", "linked_to_issue", "project_lens_of"] as const
+
+export type GithubBridgeRelationType = (typeof GITHUB_BRIDGE_RELATION_TYPES)[number]
+
+const PROJECT_FIELD_LABELS: Record<string, string> = {
+  goal: "goal",
+  current_reality: "current reality",
+  observations: "observations",
+  question: "question",
+  Status: "Status",
+  phase: "phase",
+  session_id: "session",
+  four_dir_east: "East",
+  four_dir_south: "South",
+  four_dir_west: "West",
+  four_dir_north: "North",
+  relational_assessed: "relational assessed",
+  relational_principles: "relational principles",
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+function firstString(...values: unknown[]): string | undefined {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) {
+      return value.trim()
+    }
+  }
+}
+
+function firstNumber(...values: unknown[]): number | undefined {
+  for (const value of values) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value
+    }
+    if (typeof value === "string" && value.trim()) {
+      const parsed = Number(value)
+      if (Number.isFinite(parsed)) {
+        return parsed
+      }
+    }
+  }
+}
+
+function normalizeIssueCandidate(candidate: unknown): GithubIssueRef | undefined {
+  if (!isRecord(candidate)) return undefined
+
+  const owner = firstString(candidate.owner, candidate.ownerLogin, candidate.repositoryOwner)
+  const repo = firstString(candidate.repo, candidate.repository, candidate.repositoryName)
+  const number = firstNumber(candidate.number, candidate.issue_number, candidate.issueNumber, candidate.issue)
+
+  if (!owner || !repo || !number) return undefined
+
+  return {
+    owner,
+    repo,
+    number,
+    nodeId: firstString(candidate.nodeId, candidate.node_id),
+    url: firstString(candidate.url, candidate.html_url) ?? `https://github.com/${owner}/${repo}/issues/${number}`,
+  }
+}
+
+function normalizeProjectItemCandidate(candidate: unknown, fallbackOwner?: string): GithubProjectItemRef | undefined {
+  if (!isRecord(candidate)) return undefined
+
+  const projectOwner = firstString(candidate.projectOwner, candidate.owner, candidate.ownerLogin, fallbackOwner)
+  const projectNumber = firstNumber(candidate.projectNumber, candidate.project_number, candidate.number)
+  const itemId = firstString(candidate.itemId, candidate.item_id, candidate.projectItemId, candidate.project_id)
+  const projectId = firstString(candidate.projectId, candidate.project_id)
+  const projectTitle = firstString(candidate.projectTitle, candidate.title, candidate.project)
+  const url = firstString(candidate.url)
+
+  if (!projectOwner && !projectNumber && !itemId && !projectId && !projectTitle && !url) {
+    return undefined
+  }
+
+  return {
+    ...candidate,
+    projectOwner,
+    projectNumber,
+    projectTitle,
+    itemId,
+    projectId,
+    url,
+  }
+}
+
+export function getGithubIssueRef(entity?: EntityRecord): GithubIssueRef | undefined {
+  if (!entity) return undefined
+
+  const metadata = entity.metadata ?? {}
+  const github = isRecord(metadata.github) ? metadata.github : undefined
+  const syncTarget = isRecord(metadata.sync_target) ? metadata.sync_target : undefined
+  const githubRef = isRecord(metadata.github_ref) ? metadata.github_ref : undefined
+
+  return normalizeIssueCandidate(github?.issue) ?? normalizeIssueCandidate(syncTarget) ?? normalizeIssueCandidate(githubRef)
+}
+
+export function getGithubProjectItems(entity?: EntityRecord): GithubProjectItemRef[] {
+  if (!entity) return []
+
+  const metadata = entity.metadata ?? {}
+  const github = isRecord(metadata.github) ? metadata.github : undefined
+  const syncTarget = isRecord(metadata.sync_target) ? metadata.sync_target : undefined
+  const fallbackOwner = getGithubIssueRef(entity)?.owner
+
+  if (Array.isArray(github?.projectItems)) {
+    return github.projectItems
+      .map((item) => normalizeProjectItemCandidate(item, fallbackOwner))
+      .filter((item): item is GithubProjectItemRef => Boolean(item))
+  }
+
+  const canonicalProjectItem = normalizeProjectItemCandidate(github?.projectItem, fallbackOwner)
+  if (canonicalProjectItem) {
+    return [canonicalProjectItem]
+  }
+
+  const legacyProjectItem = normalizeProjectItemCandidate(syncTarget, fallbackOwner)
+  return legacyProjectItem ? [legacyProjectItem] : []
+}
+
+export function getGithubSyncState(entityOrMetadata?: EntityRecord | Record<string, unknown>): GithubSyncState | undefined {
+  const metadata =
+    entityOrMetadata && "metadata" in entityOrMetadata && isRecord(entityOrMetadata.metadata)
+      ? entityOrMetadata.metadata
+      : entityOrMetadata
+
+  if (!isRecord(metadata)) return undefined
+
+  const github = isRecord(metadata.github) ? metadata.github : undefined
+  const syncState = github?.syncState ?? metadata.syncState
+
+  return typeof syncState === "string" && GITHUB_SYNC_STATES.includes(syncState as GithubSyncState)
+    ? (syncState as GithubSyncState)
+    : undefined
+}
+
+export function getGithubSource(entity?: EntityRecord): GithubSourceProvenance | undefined {
+  if (!entity) return undefined
+
+  const source = entity.metadata?.source
+  return isRecord(source) ? (source as GithubSourceProvenance) : undefined
+}
+
+export function getGithubEntityProvenance(entity?: EntityRecord): GithubEntityProvenance {
+  const metadata = entity?.metadata ?? {}
+  const github = isRecord(metadata.github) ? metadata.github : undefined
+  const issue = getGithubIssueRef(entity)
+  const projectItems = getGithubProjectItems(entity)
+  const syncTarget = isRecord(metadata.sync_target) ? metadata.sync_target : undefined
+  const githubRef = isRecord(metadata.github_ref) ? metadata.github_ref : undefined
+  const source = getGithubSource(entity)
+
+  return {
+    issue,
+    projectItems,
+    syncState: getGithubSyncState(entity),
+    lastSyncedAt: firstString(github?.lastSyncedAt, metadata.lastSyncedAt),
+    source,
+    hasGithubMetadata:
+      Boolean(github) ||
+      Boolean(syncTarget) ||
+      Boolean(githubRef) ||
+      source?.system === "coaia-github" ||
+      Boolean(issue) ||
+      projectItems.length > 0,
+  }
+}
+
+export function formatGithubIssueRef(issue?: GithubIssueRef): string | undefined {
+  if (!issue) return undefined
+  return `${issue.owner}/${issue.repo}#${issue.number}`
+}
+
+export function formatProjectItemRef(projectItem?: GithubProjectItemRef): string | undefined {
+  if (!projectItem) return undefined
+
+  if (projectItem.projectOwner && projectItem.projectNumber) {
+    return `${projectItem.projectOwner}/${projectItem.projectNumber}`
+  }
+
+  return projectItem.projectTitle || projectItem.itemId || projectItem.projectId || projectItem.url
+}
+
+export function getProjectFieldEntries(
+  entity: EntityRecord | undefined,
+  projectItem?: GithubProjectItemRef,
+): GithubProjectFieldEntry[] {
+  const metadata = entity?.metadata ?? {}
+  const github = isRecord(metadata.github) ? metadata.github : undefined
+  const sources = [
+    projectItem?.fields,
+    projectItem?.fieldValues,
+    projectItem?.projectFields,
+    github?.fields,
+    github?.fieldValues,
+    github?.projectFields,
+    metadata,
+    github,
+  ].filter(isRecord)
+
+  return GITHUB_PROJECT_FIELD_KEYS.flatMap((key) => {
+    for (const source of sources) {
+      if (!(key in source)) continue
+      const value = stringifyFieldValue(source[key])
+      if (value) {
+        return [{ key, label: PROJECT_FIELD_LABELS[key], value }]
+      }
+    }
+    return []
+  })
+}
+
+export function getGithubBridgeRelationType(relation: RelationRecord): GithubBridgeRelationType | undefined {
+  const relationType = relation.relationType
+  if (GITHUB_BRIDGE_RELATION_TYPES.includes(relationType as GithubBridgeRelationType)) {
+    return relationType as GithubBridgeRelationType
+  }
+
+  const metadata = relation.metadata ?? {}
+  const github = isRecord(metadata.github) ? metadata.github : undefined
+  const context = firstString(
+    metadata.context,
+    metadata.relation,
+    metadata.relationName,
+    metadata.semanticType,
+    github?.context,
+    github?.relation,
+  )
+
+  return GITHUB_BRIDGE_RELATION_TYPES.includes(context as GithubBridgeRelationType)
+    ? (context as GithubBridgeRelationType)
+    : undefined
+}
+
+function stringifyFieldValue(value: unknown): string | undefined {
+  if (value === null || value === undefined) return undefined
+  if (typeof value === "string") return value.trim() || undefined
+  if (typeof value === "number" || typeof value === "boolean") return String(value)
+  if (Array.isArray(value)) {
+    const rendered = value.map(stringifyFieldValue).filter(Boolean).join(", ")
+    return rendered || undefined
+  }
+  if (isRecord(value)) {
+    return firstString(value.name, value.text, value.value, value.title, value.label) ?? JSON.stringify(value)
+  }
+}

package/lib/jsonl-parser.ts

@@ -1,5 +1,6 @@
-import type { Chart, EntityRecord, JSONLRecord, ParsedData, RawJSONLRecord, RelationRecord, RiseSpecProjection } from "./types"
-import { buildMetadataWarnings, buildRecordProjections, normalizeJsonlRecord } from "./jsonl-preservation"
+import type { Chart, EntityRecord, JSONLRecord, ParsedData, RawJSONLRecord, RelationRecord, RiseSpecProjection } from "./types.ts"
+import { extractAsterionMetadata } from "./asterion-metadata.ts"
+import { buildMetadataWarnings, buildRecordProjections, normalizeJsonlRecord } from "./jsonl-preservation.ts"
 
 export function parseJSONL(content: string): RawJSONLRecord[] {
   const lines = content.trim().split("\n")
@@ -192,6 +193,10 @@ export function organizeData(records: RawJSONLRecord[]): ParsedData {
     }
   }
 
+  for (const chart of charts.values()) {
+    Object.assign(chart, extractAsterionMetadata(chart))
+  }
+
   // Identify root charts (level 0 or no parent)
   const rootCharts = Array.from(charts.values()).filter((chart) => chart.level === 0 || !chart.parentChart)
 

package/lib/types.ts

@@ -3,7 +3,14 @@
 export interface EntityRecord {
   type: "entity"
   name: string
-  entityType: "structural_tension_chart" | "desired_outcome" | "current_reality" | "action_step" | "narrative_beat"
+  entityType:
+    | "structural_tension_chart"
+    | "desired_outcome"
+    | "current_reality"
+    | "action_step"
+    | "narrative_beat"
+    | "custom"
+    | (string & {})
   observations: string[]
   metadata: Record<string, any>
   [key: string]: any
@@ -13,7 +20,13 @@ export interface RelationRecord {
   type: "relation"
   from: string
   to: string
-  relationType: "contains" | "creates_tension_with" | "advances_toward" | "documents"
+  relationType:
+    | "contains"
+    | "creates_tension_with"
+    | "advances_toward"
+    | "documents"
+    | "custom"
+    | (string & {})
   metadata: Record<string, any>
   [key: string]: any
 }
@@ -44,6 +57,101 @@ export interface RiseSpecProjection {
   nextOperations: string[]
 }
 
+export interface FoundationMetadata {
+  packetRoot: string
+  foundationType: string
+  parentIssue: string
+  baselineIssue: string
+  inquiryIssue: string
+  protocolIssue: string
+  schemaIssue: string
+  visualizerIssue: string
+  expectedArtifacts: string[]
+  producedArtifacts: string[]
+  evaluationStatus: "expected" | "delegated" | "produced" | "evaluated"
+  privacyClass: "public-safe" | "private" | "mixed"
+  publicationStatus: "planned" | "draft" | "reviewed" | "published"
+  commitHandles: string[]
+}
+
+export interface SessionLineageMetadata {
+  platform: string
+  parentChartId: string
+  sourceBeat: string
+  originalSessionId: string
+  branchSessionId: string
+  branchIndex: number
+  copiedMessageCount: number
+  branchPurpose: string
+  relatedIssues: string[]
+  handoffState: "requirements-created" | "implementation-ready" | "returned-to-parent"
+}
+
+export interface SessionContextMetadata {
+  mode: string
+  setting: string
+  captureQuality: "complete" | "partial" | "noisy" | "transcript-only"
+  continuationKind: "new" | "resumption" | "branch-return" | "daily-chronicle"
+  privateChroniclePath?: string
+  handle?: string
+  publicSummaryAllowed: boolean
+}
+
+export interface ParsedIssueReference {
+  key: string
+  raw: string
+  label: string
+  href?: string
+  owner?: string
+  repo?: string
+  number?: number
+}
+
+export interface ArtifactDiffEntry {
+  artifact: string
+  expected: boolean
+  produced: boolean
+  status: "matched" | "missing" | "unexpected"
+}
+
+export interface FoundationProjection {
+  foundation: Partial<FoundationMetadata>
+  warnings: MetadataWarning[]
+  issueRefs: ParsedIssueReference[]
+  artifactDiff: ArtifactDiffEntry[]
+  sourceRecords: string[]
+}
+
+export interface SessionLineageBranchProjection {
+  metadata: Partial<SessionLineageMetadata>
+  sourceRecordName?: string
+  sourceRecordType?: string
+  warnings: MetadataWarning[]
+  relatedIssueRefs: ParsedIssueReference[]
+  sourceBeatAnchor?: string
+  sourceBeatExistsInChart: boolean
+}
+
+export interface SessionLineageGroupProjection {
+  sourceBeat: string
+  sourceBeatAnchor?: string
+  sourceBeatExistsInChart: boolean
+  branches: SessionLineageBranchProjection[]
+}
+
+export interface SessionLineageProjection {
+  branches: SessionLineageBranchProjection[]
+  groupedBranches: SessionLineageGroupProjection[]
+  warnings: MetadataWarning[]
+}
+
+export interface SessionContextProjection {
+  context: Partial<SessionContextMetadata>
+  warnings: MetadataWarning[]
+  beatName: string
+  beatIndex: number
+}
+
 export interface Chart {
   id: string
   chartEntity: EntityRecord
@@ -55,6 +163,8 @@ export interface Chart {
   level: number
   parentChart?: string
   relations: RelationRecord[]
+  foundationProjection?: FoundationProjection
+  sessionLineageProjection?: SessionLineageProjection
 }
 
 export interface ParsedData {

package/mcp/test_mcp/.gemini/settings.json

@@ -0,0 +1,18 @@
+{
+  "mcpServers": {
+	   "chart-coaia-narrative-legacy-mcp": {
+         "command": "npx",
+         "args": ["-y", "${CNCV}", "--memory-path", "${memories}/trading-chart.coaia-narrative.jsonl" ]
+    },
+     "charts-mcp": {
+      "command": "node",
+      "args": [
+        "/workspace/repos/jgwill/coaia-visualizer-feat-4/mcp/dist/index.js"
+      ],
+      "env": {
+      "COAIAN_API_TOKEN":"123",
+      "COAIAV_API_URL":"http://localhost:4321"
+      }
+    }
+  }
+}

package/next-env.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/types/routes.d.ts";
+import "./.next/dev/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coaia-visualizer",
-  "version": "1.6.3",
+  "version": "1.6.5",
   "private": false,
   "type": "module",
   "main": "./index.tsx",
@@ -9,6 +9,7 @@
     ".": "./index.tsx",
     "./lib/types": "./lib/types.ts",
     "./lib/jsonl-parser": "./lib/jsonl-parser.ts",
+    "./lib/github-provenance": "./lib/github-provenance.ts",
     "./lib/utils": "./lib/utils.ts",
     "./hooks/*": "./hooks/*.ts",
     "./components/*": "./components/*.tsx",
@@ -23,25 +24,24 @@
     "components/**/*",
     "hooks/**/*",
     "lib/**/*",
-    "styles/**/*",
-    "public/**/*",
     "dist/**/*",
-    "mcp/dist/**/*",
-    "mcp/src/**/*",
-    "mcp/package.json",
-    "mcp/package-lock.json",
-    "mcp/README.md",
-    "mcp/Dockerfile",
-    "mcp/tsconfig.json",
-    "index.tsx",
+    "mcp/**/*",
+    "public/**/*",
+    "rispecs/**/*",
+    "styles/**/*",
     "cli.ts",
+    "index.tsx",
     "skill.ts",
-    "components.json",
-    "mcp-config.json",
     "next-env.d.ts",
     "next.config.mjs",
     "postcss.config.mjs",
     "tsconfig.json",
+    "Dockerfile",
+    "Dockerfile.app",
+    "docker-build-push.sh",
+    "docker-entrypoint.sh",
+    "components.json",
+    "mcp-config.json",
     "README.md",
     "README_TELESCOPED_NAVIGATION.md",
     "KINSHIP.md",
@@ -57,6 +57,7 @@
     "test": "playwright test",
     "test:rich-jsonl": "playwright test test-scripts/rich-jsonl-preservation.spec.ts",
     "test:global-cli": "playwright test test-scripts/test-global-cli.spec.ts",
+    "verify:github-provenance": "node --experimental-strip-types --experimental-specifier-resolution=node test-scripts/verify-github-provenance.mjs",
     "docker:build": "docker build -t jgwill/coaia:visualizer .",
     "docker:push": "docker push jgwill/coaia:visualizer",
     "docker:build-push": "npm run docker:build && npm run docker:push",