@hadooppei/hwcode 1.0.12 → 1.0.15

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

@@ -11,13 +11,20 @@ import { userRuntimePaths } from "../runtime/paths.ts";
 import { compactKnowledgeSummary, compactKnowledgeText, sanitizeKnowledgeText } from "./sanitize.ts";
 import type {
   KnowledgeCandidate, KnowledgeCatalog, KnowledgeCatalogEntry, KnowledgeManifest, KnowledgeReviewCursor,
-  KnowledgeReviewTask, KnowledgeScope, KnowledgeSnapshot, KnowledgeTrack, PersistKnowledgeResult,
+  KnowledgeReviewTask, KnowledgeScope, KnowledgeSkipReason, KnowledgeSnapshot, KnowledgeTrack,
+  PersistKnowledgeResult,
 } from "./types.ts";
 
 const STORAGE = KNOWLEDGE_RUNTIME_DEFAULTS.storage;
 const SAFE_ID_RE = /^[a-z0-9][a-z0-9-]{0,79}$/u;
 const SAFE_GENERATION_RE = /^[0-9TZ-]+-[a-f0-9]{12}$/u;
 const PROJECT_SCOPE_RE = /^project:[a-f0-9]{16}$/u;
+const UNVERIFIED_CLAIM_RE = /(?:待验证|尚未(?:验证|确认)|未经(?:验证|确认)|未(?:经)?证实|推测|猜测|疑似|可能是|可能由于|可能导致|或许|unverified|unconfirmed|speculat(?:e|ive|ion)|hypothes(?:is|ize)|suspect(?:ed|ion)?|possibly|probably)/iu;
+const VOLATILE_ARGUMENT_RE = /--(?:namespace|name|server_name|security_group_id|subnet_id|vpc_id|image_id|project_id)(?:\.\d+)?=(?!<[^>]+>|\$?\{)[^\s`"']+/iu;
+const DISTINCTIVE_COMMON_TERMS = new Set([
+  "cloud", "huawei", "huaweicloud", "hcloud", "topic", "rule", "sop", "project", "region", "create",
+  "deploy", "deployment", "service", "workflow", "cn", "south",
+]);
 
 export class KnowledgeCommitBusyError extends Error {}
 
@@ -137,8 +144,14 @@ function semanticDuplicateScore(candidate: KnowledgeCandidate, entry: KnowledgeC
     comparisonTerms(candidate.keywords.join(" ")),
     comparisonTerms(entry.keywords.join(" ")),
   );
-  if (titleScore < 0.8 || keywordScore < 0.5) return 0;
-  return titleScore * 0.7 + keywordScore * 0.3;
+  if (titleScore >= 0.8 && keywordScore >= 0.5) return titleScore * 0.7 + keywordScore * 0.3;
+  const candidateTerms = comparisonTerms(`${candidate.title} ${candidate.keywords.join(" ")}`);
+  const entryTerms = comparisonTerms(`${entry.title} ${entry.keywords.join(" ")}`);
+  const distinctiveShared = [...candidateTerms].filter((term) => (
+    entryTerms.has(term) && term.length >= 3 && !DISTINCTIVE_COMMON_TERMS.has(term)
+  )).length;
+  if (keywordScore < 0.5 || distinctiveShared < 3) return 0;
+  return keywordScore * 0.7 + Math.min(distinctiveShared / 6, 1) * 0.3;
 }
 
 function semanticDuplicateIndex(candidate: KnowledgeCandidate, catalog: KnowledgeCatalog): number {
@@ -151,17 +164,28 @@ function semanticDuplicateIndex(candidate: KnowledgeCandidate, catalog: Knowledg
   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());
+interface UnsupportedOperation {
+  operation: string;
+  service?: string;
+}
+
+function unsupportedOperations(value: string): UnsupportedOperation[] {
+  return [...value.matchAll(/\bOperation\s+([A-Za-z][A-Za-z0-9]+)\s+is not supported\b/gu)].map((match) => {
+    const suffix = value.slice(match.index + match[0].length, match.index + match[0].length + 500);
+    const service = /\bhcloud\s+([A-Za-z][A-Za-z0-9-]*)\s+--help\b/iu.exec(suffix)?.[1]?.toLowerCase();
+    return { operation: match[1]!.toLowerCase(), service };
+  });
 }
 
 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"));
+  for (const unsupported of unsupportedOperations(validationText)) {
+    const operationExpression = unsupported.service
+      ? new RegExp(`\\b(?:hcloud\\s+)?${unsupported.service}\\b[^\\n]{0,120}\\b${unsupported.operation}\\b`, "u")
+      : new RegExp(`\\b${unsupported.operation}\\b`, "u");
+    const index = normalizedBody.search(operationExpression);
     if (index < 0) continue;
-    const context = normalizedBody.slice(Math.max(0, index - 80), index + operation.length + 80);
+    const context = normalizedBody.slice(Math.max(0, index - 80), index + 240);
     if (!/(?:not supported|unsupported|do not|don't|avoid|不支持|不要|避免)/u.test(context)) return true;
   }
   return false;
@@ -177,25 +201,48 @@ function asStringArray(value: unknown, maxItems: number): string[] {
     .map((item) => compactKnowledgeText(item, 240)).filter(Boolean))].slice(0, maxItems);
 }
 
-function normalizeCandidate(value: unknown, projectKey: string, validationText: string): KnowledgeCandidate | undefined {
-  if (!value || typeof value !== "object") return undefined;
+type CandidateNormalization = { candidate: KnowledgeCandidate } | { reason: KnowledgeSkipReason };
+
+function withoutLeadingTitle(body: string): string {
+  return body.replace(/^#\s+[^\n]*(?:\n+|$)/u, "").trim();
+}
+
+function containsVolatileDetail(body: string, projectRoot: string): boolean {
+  const projectName = basename(resolve(projectRoot));
+  const escapedProjectName = projectName.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+  const namedProject = projectName.length >= 5
+    && new RegExp(`(?:项目|project)\\s*(?:[:：=]|is)?\\s*[\`'\"]?${escapedProjectName}(?![\\p{L}\\p{N}-])`, "iu").test(body);
+  return VOLATILE_ARGUMENT_RE.test(body)
+    || namedProject
+    || /\.hwcode\/cloud\/runs\//iu.test(body);
+}
+
+function normalizeCandidate(
+  value: unknown, projectKey: string, projectRoot: string, validationText: string,
+): CandidateNormalization {
+  if (!value || typeof value !== "object") return { reason: "invalid-schema" };
   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;
+    || typeof raw.body !== "string" || typeof raw.confidence !== "number") return { reason: "invalid-schema" };
+  if (raw.durability !== "stable") return { reason: "unstable" };
+  if (raw.confidence < KNOWLEDGE_RUNTIME_DEFAULTS.review.minimumConfidence) return { reason: "low-confidence" };
+  if (raw.targetId !== undefined && raw.targetId !== null
+    && (typeof raw.targetId !== "string" || !SAFE_ID_RE.test(raw.targetId))) return { reason: "unknown-target" };
   const explicitUserDirective = raw.explicitUserDirective === true;
   const scope: KnowledgeScope = raw.scope === "global" && explicitUserDirective ? "global" : `project:${projectKey}`;
-  const body = compactKnowledgeText(raw.body, 20_000);
+  const body = withoutLeadingTitle(compactKnowledgeText(raw.body, 20_000));
   const evidence = asStringArray(raw.evidence, 8);
-  if (!body || evidence.length === 0) return undefined;
-  if (contradictsVerifiedFailures(body, validationText)) return undefined;
+  if (!body || evidence.length === 0) return { reason: "missing-body-or-evidence" };
+  const candidateClaims = `${raw.title}\n${raw.summary}\n${body}`;
+  if (!explicitUserDirective && UNVERIFIED_CLAIM_RE.test(candidateClaims)) return { reason: "unverified-claim" };
+  if (containsVolatileDetail(body, projectRoot)) return { reason: "volatile-detail" };
+  if (contradictsVerifiedFailures(body, validationText)) return { reason: "contradicts-verified-failure" };
   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 {
+  return { candidate: {
     key: compactKnowledgeText(raw.key, 160), targetId,
     title: compactKnowledgeText(raw.title, STORAGE.maxTitleChars),
     summary: compactKnowledgeSummary(raw.summary, STORAGE.maxSummaryChars),
@@ -204,7 +251,21 @@ function normalizeCandidate(value: unknown, projectKey: string, validationText:
     storageHint: requestedTrack === "rule" && ruleEligible ? "rule" : "topic",
     action: raw.action === "revise" ? "revise" : raw.action === "reinforce" ? "reinforce" : "add",
     explicitUserDirective, durability: "stable",
-  };
+  } };
+}
+
+function recordSkip(result: PersistKnowledgeResult, reason: KnowledgeSkipReason): void {
+  result.skipped++;
+  result.skippedReasons ??= {};
+  result.skippedReasons[reason] = (result.skippedReasons[reason] ?? 0) + 1;
+}
+
+function writeRejectedPending(directory: string, reason: KnowledgeSkipReason, value: unknown): void {
+  let serialized: string;
+  try { serialized = JSON.stringify(value); } catch { serialized = String(value); }
+  const candidate = sanitizeKnowledgeText(serialized).slice(0, 10_000);
+  const name = `${Date.now()}-rejected-${reason}-${randomUUID().slice(0, 8)}.json`;
+  atomicWrite(join(directory, "pending", name), `${JSON.stringify({ reason, candidate }, null, 2)}\n`);
 }
 
 function renderKnowledgeFile(candidate: KnowledgeCandidate): string {
@@ -328,15 +389,27 @@ export function commitKnowledgeReview(
     copyCurrentContent(current, temporary, home);
     const catalog: KnowledgeCatalog = structuredClone(current.catalog);
     const result: PersistKnowledgeResult = { saved: 0, updated: 0, pending: 0, skipped: 0 };
+    const rejected: Array<{ reason: KnowledgeSkipReason; value: unknown }> = [];
     for (const value of values.slice(0, KNOWLEDGE_RUNTIME_DEFAULTS.review.maxCandidates)) {
-      const candidate = normalizeCandidate(value, task.projectKey, `${task.context ?? ""}\n${task.delta}`);
-      if (!candidate) { result.skipped++; continue; }
+      const normalized = normalizeCandidate(
+        value, task.projectKey, task.projectRoot, `${task.context ?? ""}\n${task.delta}`,
+      );
+      if (!("candidate" in normalized)) {
+        recordSkip(result, normalized.reason);
+        rejected.push({ reason: normalized.reason, value });
+        continue;
+      }
+      const candidate = normalized.candidate;
       const fingerprint = normalizedFingerprint(candidate);
       const hash = contentHash(candidate);
       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; }
+      if (candidate.targetId && targetIndex < 0) {
+        recordSkip(result, "unknown-target");
+        rejected.push({ reason: "unknown-target", value });
+        continue;
+      }
       let existingIndex = targetIndex >= 0
         ? targetIndex
         : catalog.items.findIndex((item) => item.fingerprint === fingerprint);
@@ -378,6 +451,10 @@ export function commitKnowledgeReview(
       if (existingIndex >= 0) { catalog.items[existingIndex] = entry; result.updated++; }
       else { catalog.items.push(entry); result.saved++; }
     }
+    if (result.skipped > 0 && result.saved === 0 && result.updated === 0 && result.pending === 0) {
+      for (const item of rejected) writeRejectedPending(temporary, item.reason, item.value);
+      result.pending += rejected.length;
+    }
     catalog.updatedAt = new Date().toISOString();
     const manifest: KnowledgeManifest = {
       version: 3, generationId, createdAt: new Date().toISOString(), leaderToken, catalog,

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

@@ -75,8 +75,19 @@ export interface PersistKnowledgeResult {
   updated: number;
   pending: number;
   skipped: number;
+  skippedReasons?: Partial<Record<KnowledgeSkipReason, number>>;
 }
 
+export type KnowledgeSkipReason =
+  | "invalid-schema"
+  | "unstable"
+  | "unverified-claim"
+  | "volatile-detail"
+  | "low-confidence"
+  | "missing-body-or-evidence"
+  | "contradicts-verified-failure"
+  | "unknown-target";
+
 export interface KnowledgeReviewTask {
   requestId: string;
   reviewKey: string;
@@ -89,6 +100,8 @@ export interface KnowledgeReviewTask {
   lastEntryId: string;
   context?: string;
   delta: string;
+  recallQuery?: string;
+  loadedKnowledgeIds?: string[];
   deltaDigest: string;
   fileSize: number;
   fileMtimeMs: number;

package/.pi/lib/knowledge/worker-protocol.ts

@@ -2,6 +2,7 @@ import type { KnowledgeReviewTask, PersistKnowledgeResult } from "./types.ts";
 
 export type KnowledgeWorkerInput =
   | { type: "configure"; modelAvailable: boolean; sessionsRoot: string }
+  | { type: "review_deferred"; leaderToken: string; requestId: string; reason: string }
   | { type: "review_result"; leaderToken: string; requestId: string; raw?: string; error?: string }
   | { type: "scan_now" }
   | { type: "stop" };

package/.pi/lib/working-directory.ts

@@ -189,6 +189,16 @@ export function getActiveWorkflowRoot(entries: readonly SessionEntry[]): string
 	return activeWorkflow(entries)?.root;
 }
 
+export function findLatestWorkflowRoot(entries: readonly SessionEntry[]): string | undefined {
+	for (const entry of [...entries].reverse()) {
+		if (entry.type !== "custom" || entry.customType !== "hwcode-workflow-state"
+			|| !entry.data || typeof entry.data !== "object") continue;
+		const root = (entry.data as Record<string, unknown>).root;
+		if (typeof root === "string" && root) return root;
+	}
+	return undefined;
+}
+
 export function shellQuote(value: string): string {
 	return `'${value.replaceAll("'", `'"'"'`)}'`;
 }

package/package.json

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