🎼 DevPhilharmony - Week 1 Foundation

# Install Node.js 20 (if not installed)
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
nvm install 20
nvm use 20

# Install pnpm globally
npm install -g pnpm

# Verify installations
node --version  # Should be v20.x.x
pnpm --version  # Should be 8.x.x

# Create monorepo
mkdir devphilharmony
cd devphilharmony

# Initialize pnpm workspace
pnpm init

# Create workspace structure
mkdir -p apps/web apps/mac packages/ife packages/aee packages/shared
mkdir -p packages/database packages/api

packages:
  - 'apps/*'
  - 'packages/*'

{
  "$schema": "https://turbo.build/schema.json",
  "pipeline": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": [".next/**", "dist/**"]
    },
    "dev": {
      "cache": false,
      "persistent": true
    },
    "lint": {},
    "type-check": {}
  }
}

{
  "name": "devphilharmony",
  "version": "1.0.0",
  "private": true,
  "scripts": {
    "dev": "turbo run dev",
    "build": "turbo run build",
    "lint": "turbo run lint",
    "type-check": "turbo run type-check"
  },
  "devDependencies": {
    "turbo": "^1.11.0",
    "typescript": "^5.3.3"
  }
}

# Install Supabase CLI
pnpm add -g supabase

# Login to Supabase
supabase login

# Initialize Supabase in project
cd packages/database
supabase init

# Start local Supabase (for development)
supabase start

# Anthropic (Claude)
ANTHROPIC_API_KEY=sk-ant-your-key-here

# Supabase
NEXT_PUBLIC_SUPABASE_URL=http://localhost:54321
NEXT_PUBLIC_SUPABASE_ANON_KEY=your-anon-key
SUPABASE_SERVICE_ROLE_KEY=your-service-role-key

# App Config
NEXT_PUBLIC_APP_URL=http://localhost:3000
NODE_ENV=development

-- Users table
CREATE TABLE users (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  email TEXT UNIQUE NOT NULL,
  name TEXT,
  created_at TIMESTAMPTZ DEFAULT NOW()
);

-- Projects table
CREATE TABLE projects (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  user_id UUID REFERENCES users(id),
  name TEXT NOT NULL,
  description TEXT,
  status TEXT DEFAULT 'draft', -- draft, in_progress, completed, failed
  created_at TIMESTAMPTZ DEFAULT NOW(),
  updated_at TIMESTAMPTZ DEFAULT NOW()
);

-- Dialogues table (IFE conversations)
CREATE TABLE dialogues (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  project_id UUID REFERENCES projects(id),
  role TEXT NOT NULL, -- 'user' or 'assistant'
  content TEXT NOT NULL,
  metadata JSONB, -- confidence scores, entities, etc.
  created_at TIMESTAMPTZ DEFAULT NOW()
);

-- Specifications table
CREATE TABLE specifications (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  project_id UUID REFERENCES projects(id),
  version INTEGER DEFAULT 1,
  spec_json JSONB NOT NULL, -- Complete specification
  status TEXT DEFAULT 'draft', -- draft, approved, executing
  approval_date TIMESTAMPTZ,
  created_at TIMESTAMPTZ DEFAULT NOW()
);

-- Patents/Knowledge table (your 166 inventions)
CREATE TABLE patents (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  name TEXT NOT NULL,
  description TEXT,
  claims TEXT[],
  domains TEXT[],
  embedding VECTOR(1536), -- OpenAI embeddings for semantic search
  metadata JSONB,
  created_at TIMESTAMPTZ DEFAULT NOW()
);

-- Enable vector similarity search
CREATE EXTENSION IF NOT EXISTS vector;
CREATE INDEX patents_embedding_idx ON patents 
  USING ivfflat (embedding vector_cosine_ops);

import Anthropic from '@anthropic-ai/sdk';

interface DialogueContext {
  projectId: string;
  history: Array<{role: 'user' | 'assistant', content: string}>;
  patentContext?: string[];
  confidence: number;
}

interface IntentExtraction {
  type: 'web_app' | 'mobile_app' | 'desktop_app' | 'api';
  complexity: 'simple' | 'medium' | 'complex';
  patentBasis?: string;
  features: string[];
  constraints: string[];
  confidence: number;
}

export class DialogueEngine {
  private anthropic: Anthropic;
  
  constructor(apiKey: string) {
    this.anthropic = new Anthropic({ apiKey });
  }

  /**
   * Extract initial intent from user's first message
   * Uses Claude to parse and structure the request
   */
  async extractIntent(userMessage: string): Promise<IntentExtraction> {
    const prompt = `You are an expert software architect analyzing a user's app idea.

User's request: "${userMessage}"

Extract and structure:
1. App type (web/mobile/desktop/api)
2. Complexity level (simple/medium/complex)
3. Core features mentioned
4. Any constraints mentioned (budget, timeline, tech preferences)
5. Your confidence in understanding (0.0-1.0)

Respond with JSON only.`;

    const response = await this.anthropic.messages.create({
      model: 'claude-3-sonnet-20240229',
      max_tokens: 1024,
      messages: [{ role: 'user', content: prompt }]
    });

    const content = response.content[0];
    if (content.type !== 'text') throw new Error('Unexpected response type');
    
    return JSON.parse(content.text);
  }

  /**
   * Generate clarification questions based on extracted intent
   * Uses SoafAii's incremental trust approach
   */
  async generateQuestions(
    context: DialogueContext,
    intent: IntentExtraction
  ): Promise<string[]> {
    // If confidence is high (>0.8), fewer questions needed
    if (intent.confidence > 0.8) {
      return this.generateMinimalQuestions(intent);
    }

    const prompt = `Based on this app intent:
${JSON.stringify(intent, null, 2)}

And conversation history:
${context.history.map(h => `${h.role}: ${h.content}`).join('\n')}

Generate 3-5 targeted clarification questions that will help create a complete specification.

Focus on:
1. Missing critical features
2. Unclear technical requirements
3. Constraint ambiguities
4. User experience expectations

Return as JSON array of strings.`;

    const response = await this.anthropic.messages.create({
      model: 'claude-3-sonnet-20240229',
      max_tokens: 2048,
      messages: [{ role: 'user', content: prompt }]
    });

    const content = response.content[0];
    if (content.type !== 'text') throw new Error('Unexpected response type');
    
    return JSON.parse(content.text);
  }

  /**
   * Validate if we have enough information to generate spec
   * Implements SVA³ completeness check
   */
  async validateReadiness(
    context: DialogueContext
  ): Promise<{ ready: boolean; missing: string[]; confidence: number }> {
    const prompt = `Review this conversation about building an app:

${context.history.map(h => `${h.role}: ${h.content}`).join('\n\n')}

Determine if we have enough information to generate a complete specification.

Check for:
1. Clear app purpose and target users
2. Core features defined
3. Platform(s) specified (web/mobile/desktop)
4. Technical constraints identified
5. Timeline/budget constraints understood

Respond with JSON:
{
  "ready": boolean,
  "missing": ["what's still unclear"],
  "confidence": 0.0-1.0
}`;

    const response = await this.anthropic.messages.create({
      model: 'claude-3-opus-20240229', // Use Opus for validation (higher quality)
      max_tokens: 1024,
      messages: [{ role: 'user', content: prompt }]
    });

    const content = response.content[0];
    if (content.type !== 'text') throw new Error('Unexpected response type');
    
    return JSON.parse(content.text);
  }

  private generateMinimalQuestions(intent: IntentExtraction): string[] {
    // High confidence = only essential questions
    const questions: string[] = [];
    
    if (!intent.constraints.some(c => c.includes('timeline'))) {
      questions.push('What\'s your target timeline? (e.g., 4 weeks, 3 months)');
    }
    
    if (!intent.constraints.some(c => c.includes('budget'))) {
      questions.push('What\'s your budget? (bootstrap/funded/enterprise)');
    }
    
    if (intent.type === 'web_app' || intent.type === 'mobile_app') {
      questions.push('Do you need user authentication? If yes, what level? (email/social/enterprise SSO)');
    }
    
    return questions;
  }
}

import Anthropic from '@anthropic-ai/sdk';
import { DialogueContext } from './dialogue-engine';

interface AppSpecification {
  projectId: string;
  projectName: string;
  description: string;
  
  architecture: {
    type: 'web' | 'mobile' | 'desktop' | 'fullstack';
    platforms: string[];
    techStack: {
      frontend?: string;
      backend?: string;
      database?: string;
      deployment?: string;
    };
  };
  
  features: Array<{
    id: string;
    name: string;
    description: string;
    priority: 'p0' | 'p1' | 'p2';
    acceptanceCriteria: string[];
    testScenarios: Array<{
      scenario: string;
      steps: string[];
      expectedOutcome: string;
    }>;
  }>;
  
  phases: Array<{
    id: string;
    name: string;
    durationWeeks: number;
    deliverables: string[];
    approvalRequired: boolean;
  }>;
  
  estimates: {
    timeline: string;
    cost: string;
    complexity: 'simple' | 'medium' | 'complex';
  };
  
  qaFramework: {
    unitTests: string;
    e2eTests: string;
    coverageTarget: number;
  };
}

export class SpecificationGenerator {
  private anthropic: Anthropic;
  
  constructor(apiKey: string) {
    this.anthropic = new Anthropic({ apiKey });
  }

  /**
   * Generate complete specification from validated dialogue
   * This is the IFE's final output before AEE takeover
   */
  async generateSpecification(
    context: DialogueContext
  ): Promise<AppSpecification> {
    const prompt = `You are an expert software architect generating a complete technical specification.

Conversation history:
${context.history.map(h => `${h.role}: ${h.content}`).join('\n\n')}

Generate a COMPLETE specification with:

1. Project name and description
2. Architecture (type, platforms, tech stack)
3. Features (with priorities P0/P1/P2, acceptance criteria, test scenarios)
4. Development phases (with timelines and deliverables)
5. Estimates (timeline, cost, complexity)
6. QA framework (testing approach)

IMPORTANT:
- P0 features are MVP-critical
- Each feature must have 2-3 test scenarios
- Phases should have clear milestones
- Tech stack should match user's constraints
- Be realistic about timelines

Respond with JSON matching AppSpecification schema.`;

    const response = await this.anthropic.messages.create({
      model: 'claude-3-opus-20240229', // Use Opus for spec generation (highest quality)
      max_tokens: 4096,
      messages: [{ role: 'user', content: prompt }],
      temperature: 0.3 // Lower temperature for more consistent output
    });

    const content = response.content[0];
    if (content.type !== 'text') throw new Error('Unexpected response type');
    
    const spec = JSON.parse(content.text) as AppSpecification;
    
    // Add SVA³ validation
    await this.validateSpecification(spec);
    
    return spec;
  }

  /**
   * SVA³ Validation: Completeness, Feasibility, Constraints
   * Inspired by SoafAii's triple verification
   */
  private async validateSpecification(spec: AppSpecification): Promise<void> {
    const validationPrompt = `Review this specification for:

1. COMPLETENESS: Are all required fields present? Any P0 feature missing acceptance criteria?
2. FEASIBILITY: Is the timeline realistic for the complexity? Tech stack appropriate?
3. CONSTRAINTS: Do features conflict? Are phases sequential and logical?

Specification:
${JSON.stringify(spec, null, 2)}

Respond with JSON:
{
  "valid": boolean,
  "issues": ["list of problems if any"],
  "suggestions": ["improvements"]
}`;

    const response = await this.anthropic.messages.create({
      model: 'claude-3-opus-20240229',
      max_tokens: 2048,
      messages: [{ role: 'user', content: validationPrompt }]
    });

    const content = response.content[0];
    if (content.type !== 'text') throw new Error('Unexpected response type');
    
    const validation = JSON.parse(content.text);
    
    if (!validation.valid) {
      throw new Error(`Specification validation failed: ${validation.issues.join(', ')}`);
    }
  }
}

{
  "name": "web",
  "version": "1.0.0",
  "private": true,
  "scripts": {
    "dev": "next dev",
    "build": "next build",
    "start": "next start",
    "lint": "next lint",
    "type-check": "tsc --noEmit"
  },
  "dependencies": {
    "next": "^14.1.0",
    "react": "^18.2.0",
    "react-dom": "^18.2.0",
    "@anthropic-ai/sdk": "^0.17.0",
    "@supabase/supabase-js": "^2.39.0",
    "zustand": "^4.5.0"
  },
  "devDependencies": {
    "@types/node": "^20.11.0",
    "@types/react": "^18.2.0",
    "typescript": "^5.3.3",
    "tailwindcss": "^3.4.0",
    "autoprefixer": "^10.4.17",
    "postcss": "^8.4.33"
  }
}

'use client';

import { useState } from 'react';

export default function HomePage() {
  const [intent, setIntent] = useState('');
  const [loading, setLoading] = useState(false);

  const handleStart = async () => {
    if (!intent.trim()) return;
    
    setLoading(true);
    
    // Call API to start IFE dialogue
    const response = await fetch('/api/ife/start', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ intent })
    });
    
    const { projectId } = await response.json();
    
    // Navigate to dialogue page
    window.location.href = `/dialogue/${projectId}`;
  };

  return (
    <div className="min-h-screen bg-slate-950 text-white">
      <div className="max-w-4xl mx-auto px-6 py-20">
        <h1 className="text-6xl font-bold mb-6 bg-gradient-to-r from-cyan-400 to-blue-500 bg-clip-text text-transparent">
          🎼 DevPhilharmony
        </h1>
        
        <p className="text-2xl text-slate-300 mb-12">
          Conduct Your Code Symphony: From Intent to Production in Hours
        </p>
        
        <div className="bg-slate-900 rounded-lg p-8 border border-slate-800">
          <label className="block text-lg font-semibold mb-4">
            What do you want to build?
          </label>
          
          <textarea
            value={intent}
            onChange={(e) => setIntent(e.target.value)}
            placeholder="E.g., I want to build a SaaS platform for commodity trading with broker chain visualization..."
            className="w-full h-32 bg-slate-950 border border-slate-700 rounded-lg p-4 text-white resize-none focus:outline-none focus:border-cyan-500"
          />
          
          <button
            onClick={handleStart}
            disabled={loading || !intent.trim()}
            className="mt-6 px-8 py-4 bg-cyan-500 hover:bg-cyan-600 disabled:bg-slate-700 disabled:cursor-not-allowed rounded-lg font-semibold text-lg transition-all"
          >
            {loading ? 'Starting...' : 'Start Building →'}
          </button>
        </div>
        
        <div className="mt-16 grid grid-cols-3 gap-8">
          <div className="bg-slate-900 rounded-lg p-6 border border-slate-800">
            <div className="text-3xl mb-3">🎯</div>
            <h3 className="text-xl font-semibold mb-2">Intent-Driven</h3>
            <p className="text-slate-400">
              Just describe what you want. We handle the rest.
            </p>
          </div>
          
          <div className="bg-slate-900 rounded-lg p-6 border border-slate-800">
            <div className="text-3xl mb-3">🤖</div>
            <h3 className="text-xl font-semibold mb-2">AI Agents</h3>
            <p className="text-slate-400">
              Multi-agent system builds, tests, and deploys.
            </p>
          </div>
          
          <div className="bg-slate-900 rounded-lg p-6 border border-slate-800">
            <div className="text-3xl mb-3">✅</div>
            <h3 className="text-xl font-semibold mb-2">Production Ready</h3>
            <p className="text-slate-400">
              Full stack, tested, deployed. Not a prototype.
            </p>
          </div>
        </div>
      </div>
    </div>
  );
}