@hadooppei/hwcode 1.0.10 → 1.0.12

package/.pi/lib/knowledge/store.ts

@@ -8,7 +8,7 @@ import { basename, dirname, join, resolve, sep } from "node:path";
 
 import { KNOWLEDGE_RUNTIME_DEFAULTS } from "../runtime/defaults.ts";
 import { userRuntimePaths } from "../runtime/paths.ts";
-import { compactKnowledgeText, sanitizeKnowledgeText } from "./sanitize.ts";
+import { compactKnowledgeSummary, compactKnowledgeText, sanitizeKnowledgeText } from "./sanitize.ts";
 import type {
   KnowledgeCandidate, KnowledgeCatalog, KnowledgeCatalogEntry, KnowledgeManifest, KnowledgeReviewCursor,
   KnowledgeReviewTask, KnowledgeScope, KnowledgeSnapshot, KnowledgeTrack, PersistKnowledgeResult,
@@ -117,6 +117,56 @@ function normalizedFingerprint(candidate: KnowledgeCandidate): string {
   return createHash("sha256").update(`${candidate.scope}\0${candidate.key.trim().toLowerCase()}`).digest("hex");
 }
 
+function comparisonTerms(value: string): Set<string> {
+  return new Set((value.normalize("NFKC").toLowerCase().match(/\p{Script=Han}+|[\p{L}\p{N}]+/gu) ?? [])
+    .filter((term) => term.length >= 2));
+}
+
+function containment(left: Set<string>, right: Set<string>): number {
+  const minimum = Math.min(left.size, right.size);
+  if (minimum === 0) return 0;
+  let shared = 0;
+  for (const term of left) if (right.has(term)) shared++;
+  return shared / minimum;
+}
+
+function semanticDuplicateScore(candidate: KnowledgeCandidate, entry: KnowledgeCatalogEntry): number {
+  if (candidate.scope !== entry.scope || candidate.storageHint !== entry.track) return 0;
+  const titleScore = containment(comparisonTerms(candidate.title), comparisonTerms(entry.title));
+  const keywordScore = containment(
+    comparisonTerms(candidate.keywords.join(" ")),
+    comparisonTerms(entry.keywords.join(" ")),
+  );
+  if (titleScore < 0.8 || keywordScore < 0.5) return 0;
+  return titleScore * 0.7 + keywordScore * 0.3;
+}
+
+function semanticDuplicateIndex(candidate: KnowledgeCandidate, catalog: KnowledgeCatalog): number {
+  let bestIndex = -1;
+  let bestScore = 0;
+  for (const [index, entry] of catalog.items.entries()) {
+    const score = semanticDuplicateScore(candidate, entry);
+    if (score > bestScore) { bestIndex = index; bestScore = score; }
+  }
+  return bestIndex;
+}
+
+function unsupportedOperations(value: string): string[] {
+  return [...value.matchAll(/\bOperation\s+([A-Za-z][A-Za-z0-9]+)\s+is not supported\b/gu)]
+    .map((match) => match[1]!.toLowerCase());
+}
+
+function contradictsVerifiedFailures(body: string, validationText: string): boolean {
+  const normalizedBody = body.toLowerCase();
+  for (const operation of unsupportedOperations(validationText)) {
+    const index = normalizedBody.search(new RegExp(`\\b${operation}\\b`, "u"));
+    if (index < 0) continue;
+    const context = normalizedBody.slice(Math.max(0, index - 80), index + operation.length + 80);
+    if (!/(?:not supported|unsupported|do not|don't|avoid|不支持|不要|避免)/u.test(context)) return true;
+  }
+  return false;
+}
+
 function contentHash(candidate: KnowledgeCandidate): string {
   return createHash("sha256").update(`${candidate.title}\0${candidate.summary}\0${candidate.body}`).digest("hex");
 }
@@ -127,28 +177,33 @@ function asStringArray(value: unknown, maxItems: number): string[] {
     .map((item) => compactKnowledgeText(item, 240)).filter(Boolean))].slice(0, maxItems);
 }
 
-function normalizeCandidate(value: unknown, projectKey: string): KnowledgeCandidate | undefined {
+function normalizeCandidate(value: unknown, projectKey: string, validationText: string): KnowledgeCandidate | undefined {
   if (!value || typeof value !== "object") return undefined;
   const raw = value as Record<string, unknown>;
   if (typeof raw.key !== "string" || typeof raw.title !== "string" || typeof raw.summary !== "string"
     || typeof raw.body !== "string" || typeof raw.confidence !== "number") return undefined;
+  if (raw.durability !== "stable") return undefined;
   if (raw.confidence < KNOWLEDGE_RUNTIME_DEFAULTS.review.minimumConfidence) return undefined;
   const explicitUserDirective = raw.explicitUserDirective === true;
   const scope: KnowledgeScope = raw.scope === "global" && explicitUserDirective ? "global" : `project:${projectKey}`;
   const body = compactKnowledgeText(raw.body, 20_000);
   const evidence = asStringArray(raw.evidence, 8);
   if (!body || evidence.length === 0) return undefined;
+  if (contradictsVerifiedFailures(body, validationText)) return undefined;
   const requestedTrack: KnowledgeTrack = raw.storageHint === "rule" ? "rule" : "topic";
   const ruleEligible = body.length <= STORAGE.maxRuleChars && body.split("\n").length <= STORAGE.maxRuleFileLines
+    && body.split(/\n\s*\n/gu).length === 1
     && (explicitUserDirective || raw.confidence >= 0.9);
+  const targetId = typeof raw.targetId === "string" && SAFE_ID_RE.test(raw.targetId) ? raw.targetId : undefined;
   return {
-    key: compactKnowledgeText(raw.key, 160), title: compactKnowledgeText(raw.title, STORAGE.maxTitleChars),
-    summary: compactKnowledgeText(raw.summary, STORAGE.maxSummaryChars),
+    key: compactKnowledgeText(raw.key, 160), targetId,
+    title: compactKnowledgeText(raw.title, STORAGE.maxTitleChars),
+    summary: compactKnowledgeSummary(raw.summary, STORAGE.maxSummaryChars),
     keywords: asStringArray(raw.keywords, STORAGE.maxKeywordCount).map((keyword) => keyword.toLowerCase()),
     scope, body, evidence, confidence: Math.min(1, raw.confidence),
     storageHint: requestedTrack === "rule" && ruleEligible ? "rule" : "topic",
     action: raw.action === "revise" ? "revise" : raw.action === "reinforce" ? "reinforce" : "add",
-    explicitUserDirective,
+    explicitUserDirective, durability: "stable",
   };
 }
 
@@ -274,13 +329,24 @@ export function commitKnowledgeReview(
     const catalog: KnowledgeCatalog = structuredClone(current.catalog);
     const result: PersistKnowledgeResult = { saved: 0, updated: 0, pending: 0, skipped: 0 };
     for (const value of values.slice(0, KNOWLEDGE_RUNTIME_DEFAULTS.review.maxCandidates)) {
-      const candidate = normalizeCandidate(value, task.projectKey);
+      const candidate = normalizeCandidate(value, task.projectKey, `${task.context ?? ""}\n${task.delta}`);
       if (!candidate) { result.skipped++; continue; }
       const fingerprint = normalizedFingerprint(candidate);
       const hash = contentHash(candidate);
-      const existingIndex = catalog.items.findIndex((item) => item.fingerprint === fingerprint);
+      const targetIndex = candidate.targetId
+        ? catalog.items.findIndex((item) => item.id === candidate.targetId && applicable(item, task.projectKey))
+        : -1;
+      if (candidate.targetId && targetIndex < 0) { result.skipped++; continue; }
+      let existingIndex = targetIndex >= 0
+        ? targetIndex
+        : catalog.items.findIndex((item) => item.fingerprint === fingerprint);
+      let semanticReinforcement = false;
+      if (existingIndex < 0) {
+        existingIndex = semanticDuplicateIndex(candidate, catalog);
+        semanticReinforcement = existingIndex >= 0;
+      }
       const existing = existingIndex >= 0 ? catalog.items[existingIndex] : undefined;
-      if (existing?.contentHash === hash) {
+      if (existing && (existing.contentHash === hash || candidate.action === "reinforce" || semanticReinforcement)) {
         existing.evidenceCount += candidate.evidence.length;
         existing.updatedAt = new Date().toISOString();
         result.updated++;
@@ -303,8 +369,9 @@ export function commitKnowledgeReview(
       const relativeFile = `${track === "rule" ? "rules" : "topics"}/${id}.md`;
       atomicWrite(join(temporary, relativeFile), renderKnowledgeFile(candidate));
       const entry: KnowledgeCatalogEntry = {
-        id, fingerprint, contentHash: hash, title: candidate.title, summary: candidate.summary,
-        keywords: candidate.keywords, scope: candidate.scope, track, file: relativeFile,
+        id, fingerprint: existing?.fingerprint ?? fingerprint, contentHash: hash,
+        title: candidate.title, summary: candidate.summary,
+        keywords: candidate.keywords, scope: existing?.scope ?? candidate.scope, track, file: relativeFile,
         evidenceCount: (existing?.evidenceCount ?? 0) + candidate.evidence.length,
         createdAt: existing?.createdAt ?? now, updatedAt: now,
       };

package/.pi/lib/knowledge/types.ts

@@ -1,9 +1,11 @@
 export type KnowledgeTrack = "rule" | "topic";
 export type KnowledgeScope = "global" | `project:${string}`;
 export type KnowledgeAction = "add" | "reinforce" | "revise";
+export type KnowledgeDurability = "stable";
 
 export interface KnowledgeCandidate {
   key: string;
+  targetId?: string;
   title: string;
   summary: string;
   keywords: string[];
@@ -14,6 +16,7 @@ export interface KnowledgeCandidate {
   storageHint: KnowledgeTrack;
   action: KnowledgeAction;
   explicitUserDirective: boolean;
+  durability: KnowledgeDurability;
 }
 
 export interface KnowledgeCatalogEntry {
@@ -84,6 +87,7 @@ export interface KnowledgeReviewTask {
   projectKey: string;
   firstEntryId: string;
   lastEntryId: string;
+  context?: string;
   delta: string;
   deltaDigest: string;
   fileSize: number;

package/.pi/lib/runtime/defaults.ts

@@ -31,14 +31,18 @@ export const KNOWLEDGE_RUNTIME_DEFAULTS = Object.freeze({
     intervalMs: 60_000,
     idleMs: 60_000,
     capabilityPollMs: 5_000,
-    modelTimeoutMs: 120_000,
-    maxDeltaChars: 30_000,
-    maxCandidates: 8,
+    modelTimeoutMs: 180_000,
+    maxDeltaChars: 12_000,
+    maxPriorContextChars: 4_000,
+    maxExistingContextItems: 5,
+    maxExistingBodyItems: 2,
+    maxExistingBodyChars: 600,
+    maxCandidates: 3,
     minimumConfidence: 0.72,
   }),
   storage: Object.freeze({
-    maxRuleChars: 600,
-    maxRuleFileLines: 40,
+    maxRuleChars: 320,
+    maxRuleFileLines: 6,
     maxRulesPromptChars: 12_000,
     maxMemoryChars: 25_000,
     maxMemoryLines: 200,

package/.pi/lib/runtime/paths.ts

@@ -34,6 +34,7 @@ export interface UserRuntimePaths {
   knowledgeRuntime: string;
   knowledgeCoordinatorSocket: string;
   knowledgeLeader: string;
+  knowledgeStatus: string;
   knowledgeCommitLock: string;
   knowledgeElectionLock: string;
 }
@@ -68,6 +69,7 @@ export function userRuntimePaths(home = homedir()): UserRuntimePaths {
     // Unix-domain socket paths are short on purpose (macOS caps them at roughly 104 bytes).
     knowledgeCoordinatorSocket: join(root, "knowledge-v3.sock"),
     knowledgeLeader: join(knowledge, "runtime", "leader.json"),
+    knowledgeStatus: join(knowledge, "runtime", "status.json"),
     knowledgeCommitLock: join(knowledge, "runtime", "commit.lock"),
     knowledgeElectionLock: join(knowledge, "runtime", "election.lock"),
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hadooppei/hwcode",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "description": "A customizable terminal coding agent with local-model support and HWCode workflows.",
   "type": "module",
   "bin": {