@harness-engineering/intelligence 0.1.1 → 0.1.2

package/dist/index.js

@@ -1374,16 +1374,19 @@ function computeVolumeBonus(sampleSize) {
 function bucketKey(persona, systemNodeId, taskType) {
   return `${persona}|${systemNodeId}|${taskType}`;
 }
-function computeSpecialization(store, opts) {
-  const records = gatherOutcomesWithTaskType(store);
-  if (records.length === 0) return [];
-  const temporal = opts?.temporal ?? { halfLifeDays: DEFAULT_HALF_LIFE };
-  const minSamples = opts?.minSamples ?? DEFAULT_MIN_SAMPLES;
+function matchesFilter(record, opts) {
+  if (!opts) return true;
+  const filters = [
+    [opts.persona, record.persona],
+    [opts.systemNodeId, record.systemNodeId],
+    [opts.taskType, record.taskType]
+  ];
+  return filters.every(([filter, value]) => !filter || filter === value);
+}
+function groupIntoBuckets(records, opts) {
   const buckets = /* @__PURE__ */ new Map();
   for (const record of records) {
-    if (opts?.persona && record.persona !== opts.persona) continue;
-    if (opts?.systemNodeId && record.systemNodeId !== opts.systemNodeId) continue;
-    if (opts?.taskType && record.taskType !== opts.taskType) continue;
+    if (!matchesFilter(record, opts)) continue;
     const key = bucketKey(record.persona, record.systemNodeId, record.taskType);
     let arr = buckets.get(key);
     if (!arr) {
@@ -1392,35 +1395,46 @@ function computeSpecialization(store, opts) {
     }
     arr.push(record);
   }
+  return buckets;
+}
+function computeEntryFromBucket(records, temporal) {
+  const first = records[0];
+  const { persona, systemNodeId, taskType } = first;
+  const sorted = [...records].sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
+  const tsr = temporalSuccessRate(
+    sorted.map((r) => ({ result: r.result, timestamp: r.timestamp })),
+    temporal
+  );
+  const consistency = computeConsistency(sorted.map((r) => r.result));
+  const volume = computeVolumeBonus(sorted.length);
+  const composite = W_TEMPORAL * tsr + W_CONSISTENCY * consistency + W_VOLUME * volume;
+  const lastOutcome = sorted[sorted.length - 1].timestamp;
+  const rawSuccessRate = sorted.filter((r) => r.result === "success").length / sorted.length;
+  return {
+    persona,
+    systemNodeId,
+    taskType,
+    score: {
+      temporalSuccessRate: tsr,
+      consistencyScore: consistency,
+      volumeBonus: volume,
+      composite
+    },
+    expertiseLevel: computeExpertiseLevel(sorted.length, rawSuccessRate),
+    sampleSize: sorted.length,
+    lastOutcome
+  };
+}
+function computeSpecialization(store, opts) {
+  const records = gatherOutcomesWithTaskType(store);
+  if (records.length === 0) return [];
+  const temporal = opts?.temporal ?? { halfLifeDays: DEFAULT_HALF_LIFE };
+  const minSamples = opts?.minSamples ?? DEFAULT_MIN_SAMPLES;
+  const buckets = groupIntoBuckets(records, opts);
   const entries = [];
   for (const [, records2] of buckets) {
     if (records2.length < minSamples) continue;
-    const first = records2[0];
-    const { persona, systemNodeId, taskType } = first;
-    const sorted = [...records2].sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
-    const tsr = temporalSuccessRate(
-      sorted.map((r) => ({ result: r.result, timestamp: r.timestamp })),
-      temporal
-    );
-    const consistency = computeConsistency(sorted.map((r) => r.result));
-    const volume = computeVolumeBonus(sorted.length);
-    const composite = W_TEMPORAL * tsr + W_CONSISTENCY * consistency + W_VOLUME * volume;
-    const lastOutcome = sorted[sorted.length - 1].timestamp;
-    const rawSuccessRate = sorted.filter((r) => r.result === "success").length / sorted.length;
-    entries.push({
-      persona,
-      systemNodeId,
-      taskType,
-      score: {
-        temporalSuccessRate: tsr,
-        consistencyScore: consistency,
-        volumeBonus: volume,
-        composite
-      },
-      expertiseLevel: computeExpertiseLevel(sorted.length, rawSuccessRate),
-      sampleSize: sorted.length,
-      lastOutcome
-    });
+    entries.push(computeEntryFromBucket(records2, temporal));
   }
   entries.sort((a, b) => b.score.composite - a.score.composite);
   return entries;

package/dist/index.mjs

@@ -1307,16 +1307,19 @@ function computeVolumeBonus(sampleSize) {
 function bucketKey(persona, systemNodeId, taskType) {
   return `${persona}|${systemNodeId}|${taskType}`;
 }
-function computeSpecialization(store, opts) {
-  const records = gatherOutcomesWithTaskType(store);
-  if (records.length === 0) return [];
-  const temporal = opts?.temporal ?? { halfLifeDays: DEFAULT_HALF_LIFE };
-  const minSamples = opts?.minSamples ?? DEFAULT_MIN_SAMPLES;
+function matchesFilter(record, opts) {
+  if (!opts) return true;
+  const filters = [
+    [opts.persona, record.persona],
+    [opts.systemNodeId, record.systemNodeId],
+    [opts.taskType, record.taskType]
+  ];
+  return filters.every(([filter, value]) => !filter || filter === value);
+}
+function groupIntoBuckets(records, opts) {
   const buckets = /* @__PURE__ */ new Map();
   for (const record of records) {
-    if (opts?.persona && record.persona !== opts.persona) continue;
-    if (opts?.systemNodeId && record.systemNodeId !== opts.systemNodeId) continue;
-    if (opts?.taskType && record.taskType !== opts.taskType) continue;
+    if (!matchesFilter(record, opts)) continue;
     const key = bucketKey(record.persona, record.systemNodeId, record.taskType);
     let arr = buckets.get(key);
     if (!arr) {
@@ -1325,35 +1328,46 @@ function computeSpecialization(store, opts) {
     }
     arr.push(record);
   }
+  return buckets;
+}
+function computeEntryFromBucket(records, temporal) {
+  const first = records[0];
+  const { persona, systemNodeId, taskType } = first;
+  const sorted = [...records].sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
+  const tsr = temporalSuccessRate(
+    sorted.map((r) => ({ result: r.result, timestamp: r.timestamp })),
+    temporal
+  );
+  const consistency = computeConsistency(sorted.map((r) => r.result));
+  const volume = computeVolumeBonus(sorted.length);
+  const composite = W_TEMPORAL * tsr + W_CONSISTENCY * consistency + W_VOLUME * volume;
+  const lastOutcome = sorted[sorted.length - 1].timestamp;
+  const rawSuccessRate = sorted.filter((r) => r.result === "success").length / sorted.length;
+  return {
+    persona,
+    systemNodeId,
+    taskType,
+    score: {
+      temporalSuccessRate: tsr,
+      consistencyScore: consistency,
+      volumeBonus: volume,
+      composite
+    },
+    expertiseLevel: computeExpertiseLevel(sorted.length, rawSuccessRate),
+    sampleSize: sorted.length,
+    lastOutcome
+  };
+}
+function computeSpecialization(store, opts) {
+  const records = gatherOutcomesWithTaskType(store);
+  if (records.length === 0) return [];
+  const temporal = opts?.temporal ?? { halfLifeDays: DEFAULT_HALF_LIFE };
+  const minSamples = opts?.minSamples ?? DEFAULT_MIN_SAMPLES;
+  const buckets = groupIntoBuckets(records, opts);
   const entries = [];
   for (const [, records2] of buckets) {
     if (records2.length < minSamples) continue;
-    const first = records2[0];
-    const { persona, systemNodeId, taskType } = first;
-    const sorted = [...records2].sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
-    const tsr = temporalSuccessRate(
-      sorted.map((r) => ({ result: r.result, timestamp: r.timestamp })),
-      temporal
-    );
-    const consistency = computeConsistency(sorted.map((r) => r.result));
-    const volume = computeVolumeBonus(sorted.length);
-    const composite = W_TEMPORAL * tsr + W_CONSISTENCY * consistency + W_VOLUME * volume;
-    const lastOutcome = sorted[sorted.length - 1].timestamp;
-    const rawSuccessRate = sorted.filter((r) => r.result === "success").length / sorted.length;
-    entries.push({
-      persona,
-      systemNodeId,
-      taskType,
-      score: {
-        temporalSuccessRate: tsr,
-        consistencyScore: consistency,
-        volumeBonus: volume,
-        composite
-      },
-      expertiseLevel: computeExpertiseLevel(sorted.length, rawSuccessRate),
-      sampleSize: sorted.length,
-      lastOutcome
-    });
+    entries.push(computeEntryFromBucket(records2, temporal));
   }
   entries.sort((a, b) => b.score.composite - a.score.composite);
   return entries;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harness-engineering/intelligence",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Intelligence pipeline for spec enrichment, complexity modeling, and pre-execution simulation",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -37,17 +37,17 @@
   },
   "homepage": "https://github.com/Intense-Visions/harness-engineering/tree/main/packages/intelligence#readme",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.39.0",
-    "openai": "^4.0.0",
+    "@anthropic-ai/sdk": "^0.91.0",
+    "openai": "^6.0.0",
     "zod": "^3.25.76",
-    "@harness-engineering/types": "0.10.0",
-    "@harness-engineering/graph": "0.4.3"
+    "@harness-engineering/graph": "0.5.0",
+    "@harness-engineering/types": "0.10.1"
   },
   "devDependencies": {
     "@types/node": "^22.19.15",
-    "@vitest/coverage-v8": "^4.1.2",
+    "@vitest/coverage-v8": "^4.1.5",
     "tsup": "^8.5.1",
-    "vitest": "^4.1.2"
+    "vitest": "^4.1.5"
   },
   "scripts": {
     "build": "tsup src/index.ts --format cjs,esm --dts --tsconfig tsconfig.build.json",