Improved profiles and stratified mix to use topics from the profile, rather than infer them based upon generated samples. This ensures a consistent scope is defined

Author: ScottishCoder

Docs/DATA_PROFILES.md

@@ -32,6 +32,14 @@
   "description": "Generates tasks requiring reasoning about frontend, backend, database design, API behavior, deployment, state management, architectural choices, and full-stack debugging.",
   "audience": "Full-stack developers, software engineers, architects.",
   "recordType": "alpaca",
+  "topics": [
+    "frontend",
+    "backend",
+    "api",
+    "databases",
+    "architecture",
+    "devops"
+  ],
   "useCases": [
     "Train reasoning about full-stack workflows",
     "Model backend/frontend interaction",
@@ -72,6 +80,7 @@
 - **Audience:** Full-stack developers, software engineers, architects.  
 - **Record Type:** alpaca  
 - **Use Cases:** Train reasoning about full-stack workflows; Model backend/frontend interaction; Debug end-to-end system behavior; Design scalable architectures; Analyze data flow and API correctness.  
+- **Topics:** frontend; backend; api; databases; architecture; devops.  
 - **Instruction Label:** Engineering Task  
 - **Input Label:** System Context  
 - **Output Label:** Final Answer  

components/ProfilesView.tsx

@@ -48,6 +48,7 @@ const initialBuilderState = {
     description: '',
     audience: '',
     useCases: '',
+    topics: '',
     instructionLabel: 'Instruction',
     inputLabel: 'Input',
     outputLabel: 'Response',
@@ -82,6 +83,7 @@ const ProfilesView: React.FC = () => {
         customId: 'profile-builder-custom-id',
         audience: 'profile-builder-audience',
         useCases: 'profile-builder-use-cases',
+        topics: 'profile-builder-topics',
         instructionLabel: 'profile-builder-instruction-label',
         outputLabel: 'profile-builder-output-label',
         inputLabel: 'profile-builder-input-label',
@@ -155,6 +157,7 @@ const ProfilesView: React.FC = () => {
             if (!id) throw new Error('Provide either an ID or a name to derive the ID.');
             const useCases = normalizeUseCases(builder.useCases);
             if (useCases.length === 0) throw new Error('Enter at least one use case.');
+            const topics = normalizeUseCases(builder.topics);
 
             const metadataFields = parseJsonField(builder.metadataJson, []);
             const evaluationAxes = parseJsonField(builder.evaluationJson, []);
@@ -166,6 +169,7 @@ const ProfilesView: React.FC = () => {
                 description: builder.description.trim(),
                 audience: builder.audience.trim(),
                 useCases,
+                topics: topics.length > 0 ? topics : undefined,
                 recordType: 'alpaca',
                 recordSchema: {
                     instructionLabel: builder.instructionLabel.trim() || 'Instruction',
@@ -337,6 +341,17 @@ const ProfilesView: React.FC = () => {
                                     required
                                 />
                             </div>
+                            <div>
+                                <label htmlFor={builderFieldIds.topics} className="text-xs uppercase tracking-wide text-gray-400">Topics (optional; newline or comma separated)</label>
+                                <textarea
+                                    id={builderFieldIds.topics}
+                                    name="topics"
+                                    value={builder.topics}
+                                    onChange={e => handleBuilderChange('topics', e.target.value)}
+                                    className="w-full mt-1 rounded-md bg-gray-800 border border-gray-700 p-2 text-sm text-white h-20"
+                                    placeholder="e.g. analytics&#10;governance&#10;performance"
+                                />
+                            </div>
                         </div>
 
                         <div className="grid gap-4 md:grid-cols-2">

components/StratifiedPlannerView.tsx

@@ -1,6 +1,7 @@
 import React, { useEffect, useMemo, useState } from 'react';
 import { useAppStore } from '../store/useAppStore';
-import type { DatasetRecord } from '../types';
+import { getDatasetProfile } from '../data/datasetProfiles';
+import type { DatasetRecord, DatasetProfile } from '../types';
 
 type AxisKey = 'length' | 'domain' | 'difficulty';
 type TargetConfig = Record<AxisKey, Record<string, number>>;
@@ -12,6 +13,7 @@ const DEFAULT_TARGETS: TargetConfig = {
 };
 
 const STORAGE_KEY = 'stratified-targets';
+const buildStorageKey = (profileId: string) => `${STORAGE_KEY}-${profileId || 'default'}`;
 
 const clamp = (value: number) => Math.max(0, Math.min(100, Number.isFinite(value) ? value : 0));
 
@@ -42,43 +44,110 @@ const getDifficulty = (record: DatasetRecord): string => {
     return (record as any)?.metadata?.difficulty || 'unlabeled';
 };
 
+const buildDomainTargets = (profile: DatasetProfile | null, records: DatasetRecord[]): Record<string, number> => {
+    const fromTopics = profile?.topics && profile.topics.length > 0
+        ? profile.topics.map(topic => topic.toString().toLowerCase())
+        : null;
+    if (fromTopics) {
+        const even = 100 / fromTopics.length;
+        return fromTopics.reduce<Record<string, number>>((acc, key) => {
+            acc[key] = Number(even.toFixed(2));
+            return acc;
+        }, {});
+    }
+
+    const domainCounts: Record<string, number> = {};
+    records.forEach(record => {
+        const domainKey = getDomain(record).toString().toLowerCase();
+        domainCounts[domainKey] = (domainCounts[domainKey] || 0) + 1;
+    });
+    const domainKeys = Object.keys(domainCounts);
+    if (domainKeys.length === 0) return DEFAULT_TARGETS.domain;
+
+    const evenSplit = domainKeys.reduce<Record<string, number>>((acc, key) => {
+        acc[key] = Number((100 / domainKeys.length).toFixed(2));
+        return acc;
+    }, {});
+
+    return evenSplit;
+};
+
 export const StratifiedPlannerView: React.FC = () => {
     const dataset = useAppStore(state => state.dataset);
+    const datasetProfileId = useAppStore(state => state.datasetProfileId);
     const updateConfig = useAppStore(state => state.updateConfig);
     const autoInject = useAppStore(state => state.config.autoInjectStrataPrompt ?? false);
     const lastHint = useAppStore(state => state.config.stratifiedNextAsk ?? '');
 
-    const [targets, setTargets] = useState<TargetConfig>(() => {
-        if (typeof window === 'undefined') return DEFAULT_TARGETS;
+    const filteredDataset = useMemo(() => {
+        return dataset.filter(record => (record as any)?.profileId === datasetProfileId);
+    }, [dataset, datasetProfileId]);
+
+    const storageKey = useMemo(() => buildStorageKey(String(datasetProfileId ?? 'default')), [datasetProfileId]);
+
+    const [targets, setTargets] = useState<TargetConfig>(DEFAULT_TARGETS);
+    const [hasCustomTargets, setHasCustomTargets] = useState<boolean>(false);
+    const [promptPreview, setPromptPreview] = useState<string>('');
+    const [autoInjectEnabled, setAutoInjectEnabled] = useState<boolean>(autoInject);
+    const activeProfile = useMemo(() => getDatasetProfile(datasetProfileId), [datasetProfileId]);
+
+    useEffect(() => {
+        if (typeof window === 'undefined') return;
         try {
-            const raw = window.localStorage.getItem(STORAGE_KEY);
-            if (!raw) return DEFAULT_TARGETS;
+            const raw = window.localStorage.getItem(storageKey);
+            if (!raw) {
+                setTargets({
+                    ...DEFAULT_TARGETS,
+                    domain: buildDomainTargets(activeProfile, filteredDataset),
+                });
+                setHasCustomTargets(false);
+                return;
+            }
             const parsed = JSON.parse(raw);
-            return { ...DEFAULT_TARGETS, ...parsed };
+            setTargets({ ...DEFAULT_TARGETS, ...parsed });
+            setHasCustomTargets(true);
         } catch {
-            return DEFAULT_TARGETS;
+            setTargets({
+                ...DEFAULT_TARGETS,
+                domain: buildDomainTargets(activeProfile, filteredDataset),
+            });
+            setHasCustomTargets(false);
         }
-    });
-    const [promptPreview, setPromptPreview] = useState<string>('');
-    const [autoInjectEnabled, setAutoInjectEnabled] = useState<boolean>(autoInject);
+    }, [storageKey, filteredDataset, activeProfile]);
 
     useEffect(() => {
         if (typeof window !== 'undefined') {
-            window.localStorage.setItem(STORAGE_KEY, JSON.stringify(targets));
+            window.localStorage.setItem(storageKey, JSON.stringify(targets));
         }
-    }, [targets]);
+    }, [targets, storageKey]);
 
     useEffect(() => {
         setAutoInjectEnabled(autoInject);
     }, [autoInject]);
 
+    useEffect(() => {
+        if (hasCustomTargets) return;
+        if (!filteredDataset.length && !(activeProfile?.topics?.length)) return;
+        const dynamicDefaults = {
+            ...DEFAULT_TARGETS,
+            domain: buildDomainTargets(activeProfile, filteredDataset),
+        };
+        const currentDomain = targets.domain;
+        const nextDomain = dynamicDefaults.domain;
+        const sameKeys = Object.keys(currentDomain).length === Object.keys(nextDomain).length &&
+            Object.keys(currentDomain).every(key => Math.abs((currentDomain[key] ?? 0) - (nextDomain[key] ?? 0)) < 0.001);
+        if (!sameKeys) {
+            setTargets(prev => ({ ...prev, domain: nextDomain }));
+        }
+    }, [filteredDataset, hasCustomTargets, targets.domain, activeProfile]);
+
     const stats = useMemo(() => {
         const totals: Record<AxisKey, Record<string, number>> = {
             length: {},
             domain: {},
             difficulty: {},
         };
-        dataset.forEach(record => {
+        filteredDataset.forEach(record => {
             const lengthBucket = bucketLength(record);
             totals.length[lengthBucket] = (totals.length[lengthBucket] || 0) + 1;
 
@@ -88,7 +157,7 @@ export const StratifiedPlannerView: React.FC = () => {
             const difficulty = getDifficulty(record).toString().toLowerCase();
             totals.difficulty[difficulty] = (totals.difficulty[difficulty] || 0) + 1;
         });
-        const totalRecords = dataset.length || 1;
+        const totalRecords = filteredDataset.length || 1;
         const toPercent = (counts: Record<string, number>) =>
             Object.fromEntries(
                 Object.entries(counts).map(([k, v]) => [k, Number(((v / totalRecords) * 100).toFixed(2))])
@@ -101,7 +170,7 @@ export const StratifiedPlannerView: React.FC = () => {
                 difficulty: toPercent(totals.difficulty),
             },
         };
-    }, [dataset]);
+    }, [filteredDataset]);
 
     const computeGaps = (axis: AxisKey) => {
         const desired = targets[axis];
@@ -148,7 +217,7 @@ export const StratifiedPlannerView: React.FC = () => {
     useEffect(() => {
         recomputePrompt();
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [dataset, targets]);
+    }, [filteredDataset, targets]);
 
     useEffect(() => {
         if (promptPreview && promptPreview !== lastHint) {
@@ -158,6 +227,7 @@ export const StratifiedPlannerView: React.FC = () => {
     }, [promptPreview]);
 
     const handleTargetChange = (axis: AxisKey, bucket: string, value: number) => {
+        setHasCustomTargets(true);
         setTargets(prev => ({
             ...prev,
             [axis]: {
@@ -241,7 +311,7 @@ export const StratifiedPlannerView: React.FC = () => {
                     </p>
                 </div>
                 <div className="bg-gray-800 border border-gray-700 rounded-lg px-4 py-2 text-sm text-gray-200">
-                    Dataset size: <span className="font-semibold text-white">{dataset.length.toLocaleString()}</span> records
+                    Dataset size: <span className="font-semibold text-white">{filteredDataset.length.toLocaleString()}</span> records
                 </div>
             </header>