Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
import { useState } from 'react';
import { Brain, RefreshCw, AlertCircle } from 'lucide-react';
import * as api from '../../services/api';
import toast from '../ui/Toast';
import { filterSelectableModels } from '../../utils/providers';
import { formatDateNumeric } from '../../utils/formatters';
const BIG_FIVE_LABELS = {
O: { name: 'Openness', low: 'Practical', high: 'Curious' },
C: { name: 'Conscientiousness', low: 'Flexible', high: 'Organized' },
E: { name: 'Extraversion', low: 'Reserved', high: 'Outgoing' },
A: { name: 'Agreeableness', low: 'Analytical', high: 'Empathetic' },
N: { name: 'Neuroticism', low: 'Stable', high: 'Sensitive' }
};
const TRAIT_ORDER = ['O', 'C', 'E', 'A', 'N'];
function getConfidenceColor(confidence) {
if (confidence >= 0.8) return 'text-port-success';
if (confidence >= 0.6) return 'text-port-warning';
return 'text-gray-400';
}
function getConfidenceBg(confidence) {
if (confidence >= 0.8) return 'bg-port-success';
if (confidence >= 0.6) return 'bg-port-warning';
return 'bg-gray-500';
}
export default function PersonalityMap({ traits, confidence, providers, onAnalyze }) {
const [analyzing, setAnalyzing] = useState(false);
const [selectedProvider, setSelectedProvider] = useState(
providers?.[0] ? { providerId: providers[0].id, model: providers[0].defaultModel } : null
);
const [showDetails, setShowDetails] = useState(false);
const handleAnalyze = async () => {
if (!selectedProvider) {
toast.error('Select a provider first');
return;
}
setAnalyzing(true);
const result = await api.analyzeDigitalTwinTraits(
selectedProvider.providerId,
selectedProvider.model,
true,
{ silent: true }
).catch(e => ({ error: e.message }));
if (result.error) {
toast.error(result.error);
} else {
toast.success('Traits analyzed successfully');
onAnalyze?.();
}
setAnalyzing(false);
};
const bigFive = traits?.bigFive;
const hasTraits = bigFive && Object.keys(bigFive).length > 0;
const getDimensionConfidence = (trait) => {
const dimensionMap = {
O: 'openness',
C: 'conscientiousness',
E: 'extraversion',
A: 'agreeableness',
N: 'neuroticism'
};
return confidence?.dimensions?.[dimensionMap[trait]] ?? 0.5;
};
// Radar chart calculations
const centerX = 100;
const centerY = 100;
const maxRadius = 80;
const levels = 5;
const getPoint = (index, value) => {
const angle = (Math.PI * 2 * index) / 5 - Math.PI / 2;
const radius = maxRadius * value;
return {
x: centerX + radius * Math.cos(angle),
y: centerY + radius * Math.sin(angle)
};
};
const radarPoints = hasTraits
? TRAIT_ORDER.map((trait, i) => getPoint(i, bigFive[trait] || 0.5))
: TRAIT_ORDER.map((_, i) => getPoint(i, 0.5));
const radarPath = radarPoints.map((p, i) =>
`${i === 0 ? 'M' : 'L'} ${p.x} ${p.y}`
).join(' ') + ' Z';
return (
<div className="bg-port-card rounded-lg border border-port-border p-6">
<div className="flex items-center justify-between mb-4">
<h2 className="text-lg font-semibold text-white flex items-center gap-2">
<Brain size={20} />
Personality Traits
</h2>
<button
onClick={() => setShowDetails(!showDetails)}
className="text-sm text-port-accent hover:text-white transition-colors"
>
{showDetails ? 'Hide Details' : 'Show Details'}
</button>
</div>
{!hasTraits ? (
<div className="text-center py-8">
<AlertCircle className="w-12 h-12 text-gray-500 mx-auto mb-4" />
<p className="text-gray-400 mb-4">
No personality traits analyzed yet. Run an analysis to extract Big Five traits from your documents.
</p>
<div className="flex flex-col sm:flex-row items-center justify-center gap-3">
<label htmlFor="personality-model-select" className="sr-only">AI Provider & Model</label>
<select
id="personality-model-select"
value={selectedProvider ? `${selectedProvider.providerId}:${selectedProvider.model}` : ''}
onChange={(e) => {
const [providerId, model] = e.target.value.split(':');
setSelectedProvider({ providerId, model });
}}
className="px-3 py-2 bg-port-bg border border-port-border rounded-lg text-white text-sm min-w-[200px]"
>
{providers?.map(p => (
(filterSelectableModels(p.models).length > 0 ? filterSelectableModels(p.models) : [p.defaultModel]).filter(Boolean).map(model => (
<option key={`${p.id}:${model}`} value={`${p.id}:${model}`}>
{p.name} - {model}
</option>
))
))}
</select>
<button
onClick={handleAnalyze}
disabled={analyzing}
className="px-4 py-2 bg-port-accent text-white rounded-lg text-sm hover:bg-port-accent/80 disabled:opacity-50 flex items-center gap-2"
>
{analyzing ? (
<>
<RefreshCw className="w-4 h-4 animate-spin" />
Analyzing...
</>
) : (
'Analyze Traits'
)}
</button>
</div>
</div>
) : (
<div className="flex flex-col lg:flex-row gap-6">
{/* Radar Chart */}
<div className="shrink-0 mx-auto lg:mx-0">
<svg width="200" height="200" viewBox="0 0 200 200" className="overflow-visible">
{/* Background levels */}
{Array.from({ length: levels }).map((_, i) => {
const levelRadius = (maxRadius / levels) * (i + 1);
const levelPoints = TRAIT_ORDER.map((_, j) => {
const angle = (Math.PI * 2 * j) / 5 - Math.PI / 2;
return {
x: centerX + levelRadius * Math.cos(angle),
y: centerY + levelRadius * Math.sin(angle)
};
});
const path = levelPoints.map((p, j) =>
`${j === 0 ? 'M' : 'L'} ${p.x} ${p.y}`
).join(' ') + ' Z';
return (
<path
key={i}
d={path}
fill="none"
stroke="currentColor"
strokeWidth="1"
className="text-port-border"
opacity={0.3}
/>
);
})}
{/* Axis lines */}
{TRAIT_ORDER.map((_, i) => {
const angle = (Math.PI * 2 * i) / 5 - Math.PI / 2;
const endX = centerX + maxRadius * Math.cos(angle);
const endY = centerY + maxRadius * Math.sin(angle);
return (
<line
key={i}
x1={centerX}
y1={centerY}
x2={endX}
y2={endY}
stroke="currentColor"
strokeWidth="1"
className="text-port-border"
opacity={0.3}
/>
);
})}
{/* Data polygon */}
<path
d={radarPath}
fill="currentColor"
fillOpacity="0.3"
stroke="currentColor"
strokeWidth="2"
className="text-port-accent"
/>
{/* Data points */}
{radarPoints.map((point, i) => {
const traitConfidence = getDimensionConfidence(TRAIT_ORDER[i]);
return (
<circle
key={i}
cx={point.x}
cy={point.y}
r="5"
className={getConfidenceBg(traitConfidence)}
/>
);
})}
{/* Labels */}
{TRAIT_ORDER.map((trait, i) => {
const angle = (Math.PI * 2 * i) / 5 - Math.PI / 2;
const labelRadius = maxRadius + 20;
const x = centerX + labelRadius * Math.cos(angle);
const y = centerY + labelRadius * Math.sin(angle);
const value = bigFive[trait] || 0.5;
const traitConfidence = getDimensionConfidence(trait);
return (
<g key={trait}>
<text
x={x}
y={y}
textAnchor="middle"
dominantBaseline="middle"
className={`text-xs font-medium fill-current ${getConfidenceColor(traitConfidence)}`}
>
{trait}
</text>
<text
x={x}
y={y + 12}
textAnchor="middle"
dominantBaseline="middle"
className="text-xs fill-current text-gray-500"
>
{Math.round(value * 100)}%
</text>
</g>
);
})}
</svg>
</div>
{/* Trait Details */}
<div className="flex-1 space-y-3">
{TRAIT_ORDER.map(trait => {
const value = bigFive[trait] || 0.5;
const traitConfidence = getDimensionConfidence(trait);
const label = BIG_FIVE_LABELS[trait];
return (
<div key={trait} className="space-y-1">
<div className="flex items-center justify-between">
<span className="text-sm font-medium text-white">{label.name}</span>
<span className={`text-sm ${getConfidenceColor(traitConfidence)}`}>
{Math.round(value * 100)}%
</span>
</div>
<div className="h-2 bg-port-border rounded-full overflow-hidden">
<div
className={`h-full transition-all ${getConfidenceBg(traitConfidence)}`}
style={{ width: `${value * 100}%`, opacity: 0.7 + (traitConfidence * 0.3) }}
/>
</div>
<div className="flex justify-between text-xs text-gray-500">
<span>{label.low}</span>
<span>{label.high}</span>
</div>
</div>
);
})}
{showDetails && (
<div className="mt-4 pt-4 border-t border-port-border">
<div className="flex items-center justify-between mb-2">
<span className="text-sm text-gray-400">Last analyzed</span>
<span className="text-sm text-white">
{traits.lastAnalyzed
? formatDateNumeric(traits.lastAnalyzed)
: 'Never'}
</span>
</div>
<button
onClick={handleAnalyze}
disabled={analyzing}
className="w-full mt-2 px-4 py-2 bg-port-bg border border-port-border text-white rounded-lg text-sm hover:bg-port-border disabled:opacity-50 flex items-center justify-center gap-2"
>
{analyzing ? (
<>
<RefreshCw className="w-4 h-4 animate-spin" />
Reanalyzing...
</>
) : (
'Reanalyze Traits'
)}
</button>
</div>
)}
</div>
</div>
)}
</div>
);
}