helixevo 0.2.0 → 0.2.2

package/dashboard/app/api/skills/route.ts

@@ -0,0 +1,298 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { readFileSync, writeFileSync, existsSync, rmSync, mkdirSync, readdirSync } from 'fs'
+import { join } from 'path'
+import { homedir } from 'os'
+
+const HELIX_DIR = join(homedir(), '.helix')
+const GENERAL_DIR = join(HELIX_DIR, 'general')
+
+// ─── Helpers ────────────────────────────────────────────────────
+
+function readSkillMd(slug: string): { raw: string; meta: Record<string, unknown>; content: string } | null {
+  const path = join(GENERAL_DIR, slug, 'SKILL.md')
+  if (!existsSync(path)) return null
+  const raw = readFileSync(path, 'utf-8')
+  const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/)
+  if (!match) return { raw, meta: {}, content: raw }
+
+  // Simple YAML parse (avoid importing yaml in API route)
+  const meta: Record<string, unknown> = {}
+  for (const line of match[1].split('\n')) {
+    const m = line.match(/^(\w[\w-]*?):\s*(.*)/)
+    if (m) {
+      let val: unknown = m[2].trim()
+      if (val === 'true') val = true
+      else if (val === 'false') val = false
+      else if (/^\d+(\.\d+)?$/.test(val as string)) val = parseFloat(val as string)
+      else if ((val as string).startsWith('[')) {
+        try { val = JSON.parse((val as string).replace(/'/g, '"')) } catch { /* keep as string */ }
+      }
+      // Remove quotes
+      if (typeof val === 'string' && val.startsWith('"') && val.endsWith('"')) val = val.slice(1, -1)
+      meta[m[1]] = val
+    }
+  }
+
+  return { raw, meta, content: match[2].trim() }
+}
+
+function loadGraph(): { nodes: { id: string; layer: string }[]; edges: { from: string; to: string; type: string }[] } {
+  const path = join(HELIX_DIR, 'skill-graph.json')
+  if (!existsSync(path)) return { nodes: [], edges: [] }
+  return JSON.parse(readFileSync(path, 'utf-8'))
+}
+
+function listSkills(): string[] {
+  if (!existsSync(GENERAL_DIR)) return []
+  return readdirSync(GENERAL_DIR, { withFileTypes: true })
+    .filter(d => d.isDirectory() && !d.name.startsWith('.'))
+    .map(d => d.name)
+}
+
+// ─── Network adaptation analysis ────────────────────────────────
+
+interface AdaptationResult {
+  status: 'ok' | 'warning' | 'action-needed'
+  messages: { type: 'info' | 'warning' | 'action'; text: string }[]
+  suggestions: { type: 'create' | 'merge' | 'promote' | 'rewire'; description: string }[]
+}
+
+function analyzeNetworkAdaptation(
+  action: 'update' | 'delete' | 'create' | 'promote',
+  slug: string,
+  newLayer?: string
+): AdaptationResult {
+  const graph = loadGraph()
+  const result: AdaptationResult = { status: 'ok', messages: [], suggestions: [] }
+
+  if (action === 'delete') {
+    // Check what depends on this skill
+    const dependents = graph.edges.filter(e => e.from === slug && e.type === 'inherits')
+    const enhancedBy = graph.edges.filter(e => (e.from === slug || e.to === slug) && e.type === 'enhances')
+    const dependencies = graph.edges.filter(e => e.to === slug && e.type === 'depends')
+
+    if (dependents.length > 0) {
+      result.status = 'action-needed'
+      result.messages.push({
+        type: 'warning',
+        text: `${dependents.length} skill(s) inherit from "${slug}": ${dependents.map(e => e.to).join(', ')}. They will become orphans.`
+      })
+      result.suggestions.push({
+        type: 'rewire',
+        description: `Re-assign children [${dependents.map(e => e.to).join(', ')}] to another parent before deleting`
+      })
+    }
+
+    if (dependencies.length > 0) {
+      result.status = 'warning'
+      result.messages.push({
+        type: 'warning',
+        text: `${dependencies.length} skill(s) depend on "${slug}": ${dependencies.map(e => e.from).join(', ')}`
+      })
+    }
+
+    if (enhancedBy.length > 0) {
+      result.messages.push({
+        type: 'info',
+        text: `${enhancedBy.length} enhancement edge(s) will be removed`
+      })
+    }
+
+    // Check if deletion creates a coverage gap
+    const allSlugs = listSkills()
+    if (allSlugs.length <= 3) {
+      result.status = 'warning'
+      result.messages.push({
+        type: 'warning',
+        text: 'Removing this skill will leave very few skills. Consider merging instead of deleting.'
+      })
+    }
+  }
+
+  if (action === 'update') {
+    // Check if co-evolved skills might be affected
+    const coEvolved = graph.edges.filter(
+      e => (e.from === slug || e.to === slug) && (e.type === 'co-evolves' || e.type === 'enhances')
+    )
+    if (coEvolved.length > 0) {
+      const partners = coEvolved.map(e => e.from === slug ? e.to : e.from)
+      result.messages.push({
+        type: 'info',
+        text: `This skill co-evolves with [${partners.join(', ')}]. Changes may affect their behavior.`
+      })
+      result.suggestions.push({
+        type: 'rewire',
+        description: `Review golden cases for [${partners.join(', ')}] after this change`
+      })
+    }
+  }
+
+  if (action === 'promote') {
+    // Check if promotion makes sense
+    const currentSkill = readSkillMd(slug)
+    const currentLayer = (currentSkill?.meta?.layer as string) ?? 'domain'
+
+    if (newLayer === 'system' && currentLayer === 'project') {
+      result.status = 'warning'
+      result.messages.push({
+        type: 'warning',
+        text: 'Promoting directly from project to system. Consider promoting to domain first.'
+      })
+    }
+
+    // Check if similar domain skill already exists
+    const allSlugs = listSkills()
+    const domainSkills = allSlugs.filter(s => {
+      const sk = readSkillMd(s)
+      return sk?.meta?.layer === 'domain' && s !== slug
+    })
+
+    if (domainSkills.length > 0 && newLayer === 'domain') {
+      result.messages.push({
+        type: 'info',
+        text: `${domainSkills.length} domain skill(s) exist. Check for overlap before promoting.`
+      })
+      result.suggestions.push({
+        type: 'merge',
+        description: `Consider merging with existing domain skills instead of creating a new one`
+      })
+    }
+  }
+
+  if (action === 'create') {
+    // Check if similar skill already exists
+    const existingSlugs = listSkills()
+    if (existingSlugs.includes(slug)) {
+      result.status = 'warning'
+      result.messages.push({
+        type: 'warning',
+        text: `Skill "${slug}" already exists. This will overwrite it.`
+      })
+    }
+
+    // Suggest connecting to existing skills
+    if (graph.nodes.length > 0) {
+      result.suggestions.push({
+        type: 'rewire',
+        description: 'After creating, run "helixevo graph --rebuild" to detect relationships with existing skills'
+      })
+    }
+  }
+
+  if (result.messages.length === 0) {
+    result.messages.push({ type: 'info', text: 'Network can adapt to this change without issues.' })
+  }
+
+  return result
+}
+
+// ─── GET: List all skills or get one ────────────────────────────
+
+export async function GET(request: NextRequest) {
+  const slug = request.nextUrl.searchParams.get('slug')
+
+  if (slug) {
+    const skill = readSkillMd(slug)
+    if (!skill) return NextResponse.json({ error: 'Skill not found' }, { status: 404 })
+    return NextResponse.json({ slug, ...skill })
+  }
+
+  // List all skills
+  const slugs = listSkills()
+  const skills = slugs.map(s => {
+    const skill = readSkillMd(s)
+    return {
+      slug: s,
+      name: skill?.meta?.name ?? s,
+      description: skill?.meta?.description ?? '',
+      layer: skill?.meta?.layer ?? 'domain',
+      score: skill?.meta?.score ?? 0.7,
+      generation: skill?.meta?.generation ?? 0,
+      tags: skill?.meta?.tags ?? [],
+    }
+  })
+
+  return NextResponse.json({ skills })
+}
+
+// ─── PUT: Update a skill ────────────────────────────────────────
+
+export async function PUT(request: NextRequest) {
+  const body = await request.json()
+  const { slug, content, layer } = body
+
+  if (!slug) return NextResponse.json({ error: 'slug required' }, { status: 400 })
+
+  // Promote/demote layer
+  if (layer && !content) {
+    const skill = readSkillMd(slug)
+    if (!skill) return NextResponse.json({ error: 'Skill not found' }, { status: 404 })
+
+    const adaptation = analyzeNetworkAdaptation('promote', slug, layer)
+
+    // Update layer in the raw file
+    const updated = skill.raw.replace(
+      /^(layer:\s*).*$/m,
+      `$1${layer}`
+    )
+    // If no layer field, add it after description
+    const finalContent = updated.includes('layer:')
+      ? updated
+      : skill.raw.replace(/(description:.*\n)/, `$1layer: ${layer}\n`)
+
+    const skillPath = join(GENERAL_DIR, slug, 'SKILL.md')
+    writeFileSync(skillPath, finalContent)
+
+    return NextResponse.json({ success: true, slug, layer, adaptation })
+  }
+
+  // Update content
+  if (content) {
+    const adaptation = analyzeNetworkAdaptation('update', slug)
+    const skillDir = join(GENERAL_DIR, slug)
+    if (!existsSync(skillDir)) mkdirSync(skillDir, { recursive: true })
+    writeFileSync(join(skillDir, 'SKILL.md'), content)
+
+    return NextResponse.json({ success: true, slug, adaptation })
+  }
+
+  return NextResponse.json({ error: 'content or layer required' }, { status: 400 })
+}
+
+// ─── POST: Create a new skill ───────────────────────────────────
+
+export async function POST(request: NextRequest) {
+  const body = await request.json()
+  const { slug, content } = body
+
+  if (!slug || !content) {
+    return NextResponse.json({ error: 'slug and content required' }, { status: 400 })
+  }
+
+  const adaptation = analyzeNetworkAdaptation('create', slug)
+
+  const skillDir = join(GENERAL_DIR, slug)
+  mkdirSync(skillDir, { recursive: true })
+  writeFileSync(join(skillDir, 'SKILL.md'), content)
+
+  return NextResponse.json({ success: true, slug, adaptation })
+}
+
+// ─── DELETE: Remove a skill ─────────────────────────────────────
+
+export async function DELETE(request: NextRequest) {
+  const slug = request.nextUrl.searchParams.get('slug')
+  if (!slug) return NextResponse.json({ error: 'slug required' }, { status: 400 })
+
+  const skillDir = join(GENERAL_DIR, slug)
+  if (!existsSync(skillDir)) {
+    return NextResponse.json({ error: 'Skill not found' }, { status: 404 })
+  }
+
+  // Analyze impact BEFORE deleting
+  const adaptation = analyzeNetworkAdaptation('delete', slug)
+
+  rmSync(skillDir, { recursive: true })
+
+  return NextResponse.json({ success: true, slug, adaptation })
+}

package/dashboard/app/evolution/page.tsx

@@ -0,0 +1,128 @@
+import { loadHistory } from '@/lib/data'
+
+export const dynamic = 'force-dynamic'
+
+export default function EvolutionPage() {
+  const history = loadHistory()
+  const iterations = [...history.iterations].reverse()
+  const total = iterations.flatMap(i => i.proposals)
+  const accepted = total.filter(p => p.outcome === 'accepted').length
+  const rejected = total.filter(p => p.outcome === 'rejected').length
+
+  return (
+    <div>
+      <div className="page-header">
+        <h1 className="page-title">Evolution Timeline</h1>
+        <p className="page-desc">
+          {iterations.length} runs · {accepted} accepted · {rejected} rejected
+        </p>
+      </div>
+
+      {/* Summary Stats */}
+      <div className="grid-3" style={{ marginBottom: 28 }}>
+        <div className="stat-card">
+          <div className="stat-value" style={{ color: 'var(--purple)' }}>{iterations.length}</div>
+          <div className="stat-label">Evolution Runs</div>
+        </div>
+        <div className="stat-card">
+          <div className="stat-value" style={{ color: 'var(--green)' }}>{accepted}</div>
+          <div className="stat-label">Proposals Accepted</div>
+        </div>
+        <div className="stat-card">
+          <div className="stat-value" style={{ color: 'var(--red)' }}>{rejected}</div>
+          <div className="stat-label">Proposals Rejected</div>
+        </div>
+      </div>
+
+      {/* Timeline */}
+      <div style={{ paddingLeft: 20, position: 'relative' }}>
+        <div style={{ position: 'absolute', left: 9, top: 0, bottom: 0, width: 2, background: 'var(--border)' }} />
+
+        {iterations.map(iter => (
+          <div key={iter.id} style={{ position: 'relative', marginBottom: 24, paddingLeft: 28 }}>
+            {/* Timeline dot */}
+            <div style={{
+              position: 'absolute', left: -1, top: 4, width: 14, height: 14,
+              borderRadius: '50%', background: 'var(--purple)', border: '3px solid var(--bg)',
+              boxShadow: '0 0 0 2px var(--purple-light)',
+            }} />
+
+            {/* Run Header */}
+            <div style={{ display: 'flex', alignItems: 'baseline', gap: 10, marginBottom: 10 }}>
+              <span style={{ fontSize: 15, fontWeight: 700 }}>{iter.id}</span>
+              <span style={{ fontSize: 12, color: 'var(--text-dim)' }}>
+                {new Date(iter.timestamp).toLocaleString()} · {iter.trigger} · {iter.failureCount} failures
+              </span>
+            </div>
+
+            {/* Clusters */}
+            {iter.failureClusters.length > 0 && (
+              <div style={{ display: 'flex', gap: 6, marginBottom: 10, flexWrap: 'wrap' }}>
+                {iter.failureClusters.map((c, i) => (
+                  <span key={i} className="badge badge-blue">{c.type} ({c.count})</span>
+                ))}
+              </div>
+            )}
+
+            {/* Proposals */}
+            {iter.proposals.map(p => (
+              <div key={p.id} className="proposal-card" style={{
+                borderLeft: `3px solid ${p.outcome === 'accepted' ? 'var(--green)' : 'var(--red)'}`,
+              }}>
+                <div style={{ padding: '12px 16px' }}>
+                  {/* Proposal Header */}
+                  <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: 8 }}>
+                    <div style={{ display: 'flex', alignItems: 'center', gap: 6 }}>
+                      <span className={`badge ${p.outcome === 'accepted' ? 'badge-green' : 'badge-red'}`}>
+                        {p.outcome}
+                      </span>
+                      <span style={{ fontSize: 14, fontWeight: 600 }}>{p.targetSkill}</span>
+                      <span className="badge badge-gray">{p.action}</span>
+                    </div>
+                  </div>
+
+                  {/* Description */}
+                  <p style={{ fontSize: 12, color: 'var(--text-secondary)', marginBottom: 10, lineHeight: 1.5 }}>
+                    {p.description.slice(0, 200)}
+                  </p>
+
+                  {/* Judge Scores */}
+                  <div style={{ display: 'flex', gap: 10, marginBottom: 6 }}>
+                    {[
+                      { label: 'Task', score: p.judges.taskCompletion.score, color: 'var(--green)' },
+                      { label: 'Align', score: p.judges.correctionAlignment.score, color: 'var(--blue)' },
+                      { label: 'Side-effects', score: p.judges.sideEffectCheck.score, color: 'var(--purple)' },
+                    ].map(j => (
+                      <div key={j.label} style={{ display: 'flex', alignItems: 'center', gap: 4, fontSize: 12 }}>
+                        <span style={{ color: 'var(--text-dim)' }}>{j.label}:</span>
+                        <b style={{ color: j.score >= 7 ? j.color : 'var(--red)' }}>{j.score}/10</b>
+                      </div>
+                    ))}
+                    {p.regressionResult.total > 0 && (
+                      <div style={{ display: 'flex', alignItems: 'center', gap: 4, fontSize: 12 }}>
+                        <span style={{ color: 'var(--text-dim)' }}>Regression:</span>
+                        <b>{p.regressionResult.passed}/{p.regressionResult.total}</b>
+                      </div>
+                    )}
+                  </div>
+
+                  {/* Outcome Reason */}
+                  <div style={{ fontSize: 11, color: 'var(--text-muted)', lineHeight: 1.4 }}>{p.outcomeReason}</div>
+                </div>
+              </div>
+            ))}
+          </div>
+        ))}
+
+        {iterations.length === 0 && (
+          <div className="card" style={{ marginLeft: 28 }}>
+            <div className="empty-state">
+              <div className="empty-state-title">No evolution runs yet</div>
+              <div className="empty-state-desc">Run <code>helixevo evolve</code> to start the evolution loop</div>
+            </div>
+          </div>
+        )}
+      </div>
+    </div>
+  )
+}

package/dashboard/app/frontier/page.tsx

@@ -0,0 +1,128 @@
+import { loadFrontier, loadCanaries } from '@/lib/data'
+
+export const dynamic = 'force-dynamic'
+
+export default function FrontierPage() {
+  const frontier = loadFrontier()
+  const canaries = loadCanaries()
+
+  return (
+    <div>
+      <div className="page-header">
+        <h1 className="page-title">Pareto Frontier</h1>
+        <p className="page-desc">
+          Top {frontier.capacity} skill configurations ranked by composite score
+        </p>
+      </div>
+
+      {/* Frontier Programs */}
+      <div style={{ display: 'grid', gap: 12, marginBottom: 28 }}>
+        {frontier.programs.map((p, rank) => (
+          <div key={`${p.id}-${rank}`} className="card" style={{ overflow: 'hidden' }}>
+            <div className="card-body" style={{ position: 'relative' }}>
+              {/* Rank Badge */}
+              <div style={{
+                position: 'absolute', top: 0, right: 0,
+                padding: '4px 16px',
+                background: rank === 0 ? 'var(--purple)' : rank === 1 ? 'var(--blue)' : 'var(--bg-section)',
+                color: rank <= 1 ? '#fff' : 'var(--text-dim)',
+                borderBottomLeftRadius: 10, fontSize: 12, fontWeight: 700,
+              }}>
+                #{rank + 1}
+              </div>
+
+              {/* Header */}
+              <div style={{ marginBottom: 16 }}>
+                <div style={{ fontSize: 17, fontWeight: 700 }}>{p.id}</div>
+                <div style={{ fontSize: 12, color: 'var(--text-dim)', marginTop: 2 }}>
+                  gen {p.generation} · {new Date(p.createdAt).toLocaleDateString()}
+                </div>
+              </div>
+
+              {/* Score Grid */}
+              <div className="grid-4" style={{ marginBottom: 16 }}>
+                {[
+                  { label: 'Composite', value: p.score, color: 'var(--purple)' },
+                  { label: 'Task', value: p.scores.taskCompletion, color: 'var(--green)' },
+                  { label: 'Alignment', value: p.scores.correctionAlignment, color: 'var(--blue)' },
+                  { label: 'Side-Effect Free', value: p.scores.sideEffectFree, color: 'var(--yellow)' },
+                ].map(s => (
+                  <div key={s.label} style={{
+                    padding: '10px 12px',
+                    background: 'var(--bg-section)',
+                    borderRadius: 10,
+                  }}>
+                    <div style={{
+                      fontSize: 9, color: 'var(--text-muted)', textTransform: 'uppercase',
+                      letterSpacing: 1, marginBottom: 4, fontWeight: 600,
+                    }}>{s.label}</div>
+                    <div style={{
+                      fontSize: 22, fontWeight: 800, lineHeight: 1,
+                      color: s.value >= 0.8 ? 'var(--green)' : s.value >= 0.6 ? 'var(--yellow)' : 'var(--red)',
+                    }}>
+                      {(s.value * 100).toFixed(0)}
+                    </div>
+                    <div className="score-track" style={{ height: 4, marginTop: 6 }}>
+                      <div className="score-fill" style={{
+                        width: `${s.value * 100}%`,
+                        background: s.value >= 0.8 ? 'var(--green)' : s.value >= 0.6 ? 'var(--yellow)' : 'var(--red)',
+                      }} />
+                    </div>
+                  </div>
+                ))}
+              </div>
+
+              {/* Description */}
+              <div style={{ fontSize: 12, color: 'var(--text-secondary)', lineHeight: 1.5 }}>
+                {p.changesDescription.slice(0, 200)}
+              </div>
+            </div>
+          </div>
+        ))}
+
+        {frontier.programs.length === 0 && (
+          <div className="card">
+            <div className="empty-state">
+              <div className="empty-state-title">Frontier empty</div>
+              <div className="empty-state-desc">Run <code>helixevo evolve</code> to populate the frontier</div>
+            </div>
+          </div>
+        )}
+      </div>
+
+      {/* Canaries */}
+      <div className="card">
+        <div className="card-body">
+          <div className="card-header-label">Active Canaries</div>
+          {canaries.entries.length > 0 ? (
+            canaries.entries.map((c, i) => {
+              const daysLeft = Math.max(0, Math.ceil((new Date(c.expiresAt).getTime() - Date.now()) / (24 * 60 * 60 * 1000)))
+              return (
+                <div key={i} style={{
+                  display: 'flex', justifyContent: 'space-between', alignItems: 'center',
+                  padding: '10px 0', borderBottom: i < canaries.entries.length - 1 ? '1px solid var(--border-subtle)' : 'none',
+                }}>
+                  <div style={{ display: 'flex', alignItems: 'center', gap: 10 }}>
+                    <div style={{
+                      width: 8, height: 8, borderRadius: '50%',
+                      background: daysLeft > 0 ? 'var(--yellow)' : 'var(--green)',
+                    }} />
+                    <span style={{ fontWeight: 500, fontSize: 13 }}>{c.skillSlug}</span>
+                    <span style={{ color: 'var(--text-muted)', fontSize: 11 }}>{c.version}</span>
+                  </div>
+                  <span className={`badge ${daysLeft > 0 ? 'badge-yellow' : 'badge-green'}`}>
+                    {daysLeft > 0 ? `${daysLeft}d remaining` : 'Ready to promote'}
+                  </span>
+                </div>
+              )
+            })
+          ) : (
+            <div style={{ color: 'var(--text-dim)', fontSize: 13, textAlign: 'center', padding: 20 }}>
+              No active canaries
+            </div>
+          )}
+        </div>
+      </div>
+    </div>
+  )
+}