@oswaldzsh/devhive 0.1.0

package/signature/learner.py

@@ -0,0 +1,75 @@
+"""Signature learner — automatically extracts new signatures from resolved escalations."""
+
+import json
+import hashlib
+from datetime import datetime, timezone
+from typing import Optional
+
+
+class SignatureLearner:
+    """Creates new signatures from resolved human interventions."""
+
+    def __init__(self, signature_db, extractor=None):
+        self.db = signature_db
+        self.extractor = extractor
+
+    def learn_from_escalation(
+        self,
+        task_id: str,
+        error_output: str,
+        changed_files: list[str],
+        root_cause: str,
+        root_cause_category: str,
+        fix_strategy: str,
+        fix_template: str,
+        verification_required: list[str] = None,
+    ) -> str:
+        """Create a new signature from a resolved escalation.
+
+        Returns the new signature_id.
+        """
+        from signature.extractor import extract_feature_vector
+
+        fv_data = extract_feature_vector(error_output, changed_files)
+        fv = fv_data["feature_vector"]
+
+        sig_id = f"sig-{hashlib.sha256(error_output.encode()).hexdigest()[:10]}"
+
+        signature = {
+            "signature_id": sig_id,
+            "created_at": datetime.now(timezone.utc).replace(tzinfo=None).isoformat(),
+            "last_matched": datetime.now(timezone.utc).replace(tzinfo=None).isoformat(),
+            "match_count": 0,
+            "feature_vector": fv,
+            "diagnosis": {
+                "root_cause": root_cause,
+                "root_cause_category": root_cause_category,
+                "reliability": 0.5,  # Starts low, increases with successful matches
+            },
+            "resolution": {
+                "strategy": fix_strategy,
+                "fix_template": fix_template,
+                "verification_required": verification_required or [],
+            },
+            "source_task": task_id,
+        }
+
+        self.db.add(signature)
+        return sig_id
+
+    def reinforce(self, sig_id: str, success: bool = True):
+        """Update signature reliability based on match outcome."""
+        sig = self.db.get(sig_id)
+        if not sig:
+            return
+
+        diag = sig.get("diagnosis", {})
+        current = diag.get("reliability", 0.5)
+
+        if success:
+            diag["reliability"] = min(1.0, current + 0.05)
+        else:
+            diag["reliability"] = max(0.1, current - 0.1)
+
+        sig["diagnosis"] = diag
+        self.db.add(sig)  # Overwrites

package/signature/src/matcher.c

@@ -0,0 +1,263 @@
+/*
+ * matcher.c — Signature Matching Engine Implementation
+ */
+
+#include "matcher.h"
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+/* ── Helpers ───────────────────────────────────────────────── */
+
+static int min_int(int a, int b) { return a < b ? a : b; }
+
+/* Jaccard similarity for two sets of uint64 hashes */
+static double jaccard_hashes(const uint64_t *a, int a_len,
+                              const uint64_t *b, int b_len) {
+    if (a_len == 0 && b_len == 0) return 1.0;
+    if (a_len == 0 || b_len == 0) return 0.0;
+
+    int intersection = 0;
+    for (int i = 0; i < a_len; i++) {
+        if (a[i] == 0) continue;
+        for (int j = 0; j < b_len; j++) {
+            if (a[i] == b[j]) {
+                intersection++;
+                break;
+            }
+        }
+    }
+    int union_size = a_len + b_len - intersection;
+    return union_size > 0 ? (double)intersection / union_size : 0.0;
+}
+
+/* Check if two strings share a common prefix path (e.g., same directory) */
+static double location_similarity(const char *a, const char *b) {
+    if (strcmp(a, b) == 0) return 1.0;
+    if (a[0] == '\0' || b[0] == '\0') return 0.0;
+
+    /* Find the last '/' to split into dir + filename */
+    const char *slash_a = strrchr(a, '/');
+    const char *slash_b = strrchr(b, '/');
+
+    if (slash_a && slash_b) {
+        /* Compare directory parts */
+        int dir_len_a = (int)(slash_a - a);
+        int dir_len_b = (int)(slash_b - b);
+        if (dir_len_a == dir_len_b && strncmp(a, b, dir_len_a) == 0) {
+            /* Same directory → 0.7 */
+            /* Same filename → check */
+            if (strcmp(slash_a + 1, slash_b + 1) == 0) return 1.0;
+            return 0.7;
+        }
+        return 0.0;
+    }
+
+    return strcmp(a, b) == 0 ? 1.0 : 0.0;
+}
+
+/* ── Hash ──────────────────────────────────────────────────── */
+
+uint64_t hash_error_message(const char *msg) {
+    /* FNV-1a 64-bit hash */
+    uint64_t hash = 14695981039346656037ULL;
+    if (!msg) return hash;
+
+    /* Normalize: lowercase, collapse whitespace */
+    char c;
+    int last_was_space = 0;
+    while ((c = *msg++)) {
+        /* Lowercase */
+        if (c >= 'A' && c <= 'Z') c += 32;
+        /* Collapse whitespace */
+        if (c == ' ' || c == '\t' || c == '\n' || c == '\r') {
+            if (last_was_space) continue;
+            c = ' ';
+            last_was_space = 1;
+        } else {
+            last_was_space = 0;
+        }
+        hash ^= (uint64_t)(unsigned char)c;
+        hash *= 1099511628211ULL;
+    }
+    return hash;
+}
+
+void extract_location_pattern(const char *file_line, char *out, int out_len) {
+    if (!file_line || !out || out_len <= 0) return;
+    out[0] = '\0';
+
+    const char *colon = strrchr(file_line, ':');
+    int copy_len;
+    if (colon) {
+        copy_len = min_int((int)(colon - file_line), out_len - 1);
+    } else {
+        copy_len = min_int((int)strlen(file_line), out_len - 1);
+    }
+    strncpy(out, file_line, copy_len);
+    out[copy_len] = '\0';
+}
+
+/* ── Database ──────────────────────────────────────────────── */
+
+SignatureDB* db_create(int initial_capacity) {
+    SignatureDB *db = (SignatureDB*)calloc(1, sizeof(SignatureDB));
+    if (!db) return NULL;
+
+    db->capacity = initial_capacity > 0 ? initial_capacity : 256;
+    db->signatures = (Signature*)calloc(db->capacity, sizeof(Signature));
+    if (!db->signatures) {
+        free(db);
+        return NULL;
+    }
+    db->count = 0;
+    return db;
+}
+
+void db_destroy(SignatureDB *db) {
+    if (!db) return;
+    free(db->signatures);
+    free(db);
+}
+
+int db_add(SignatureDB *db, const Signature *sig) {
+    if (!db || !sig || db->count >= db->capacity) {
+        /* Attempt to grow */
+        if (db && db->count >= db->capacity) {
+            int new_cap = db->capacity * 2;
+            Signature *new_sigs = (Signature*)realloc(
+                db->signatures, new_cap * sizeof(Signature));
+            if (!new_sigs) return -1;
+            db->signatures = new_sigs;
+            db->capacity = new_cap;
+        } else {
+            return -1;
+        }
+    }
+    memcpy(&db->signatures[db->count], sig, sizeof(Signature));
+    db->count++;
+    return 0;
+}
+
+/* ── Similarity Computation ────────────────────────────────── */
+
+double vector_similarity(const MatcherConfig *config,
+                         const FeatureVector *a, const FeatureVector *b) {
+    double score = 0.0;
+
+    /* 1. Error type match (exact) */
+    score += config->w_error_type *
+        (strcmp(a->error_type, b->error_type) == 0 ? 1.0 : 0.0);
+
+    /* 2. Error message hash similarity */
+    score += config->w_error_message *
+        (a->error_message_hash == b->error_message_hash ? 1.0 :
+         (a->error_message_hash && b->error_message_hash ? 0.1 : 0.0));
+
+    /* 3. Location similarity */
+    score += config->w_location *
+        location_similarity(a->location_pattern, b->location_pattern);
+
+    /* 4. Stack trace similarity (Jaccard) */
+    score += config->w_stack_trace *
+        jaccard_hashes(a->stack_hashes, a->stack_depth,
+                       b->stack_hashes, b->stack_depth);
+
+    /* 5. Change context similarity */
+    double ctx_sim = 0.0;
+    if (a->change_type == b->change_type) ctx_sim += 0.5;
+    if (a->distance_to_error == b->distance_to_error) ctx_sim += 0.5;
+    score += config->w_change_context * ctx_sim;
+
+    /* 6. Temporal bonus — if the signature was recently active */
+    if (b->is_new_in_diff) {
+        score += config->w_temporal * 0.5;
+    }
+
+    return score;
+}
+
+/* ── Matching ──────────────────────────────────────────────── */
+
+static int compare_results(const void *a, const void *b) {
+    const MatchResult *ra = (const MatchResult *)a;
+    const MatchResult *rb = (const MatchResult *)b;
+    if (ra->similarity > rb->similarity) return -1;
+    if (ra->similarity < rb->similarity) return 1;
+    return 0;
+}
+
+int db_match(const SignatureDB *db, const MatcherConfig *config,
+             const FeatureVector *query,
+             MatchResult *results, int k) {
+    if (!db || !config || !query || !results || k <= 0) return 0;
+
+    int result_count = 0;
+
+    /* Linear scan with top-K tracking */
+    for (int i = 0; i < db->count; i++) {
+        double sim = vector_similarity(config, query,
+                                       &db->signatures[i].features);
+        if (sim < config->min_confidence) continue;
+
+        /* Insert into sorted results array */
+        if (result_count < k) {
+            /* Fill first k slots */
+            int pos = result_count;
+            while (pos > 0 && results[pos - 1].similarity < sim) {
+                results[pos] = results[pos - 1];
+                pos--;
+            }
+            memset(&results[pos], 0, sizeof(MatchResult));
+            strncpy(results[pos].sig_id, db->signatures[i].sig_id,
+                    MATCHER_MAX_SIG_ID - 1);
+            results[pos].similarity = sim;
+            results[pos].reliability = db->signatures[i].reliability;
+            results[pos].match_count = db->signatures[i].match_count;
+            strncpy(results[pos].resolution_strategy,
+                    db->signatures[i].resolution_strategy,
+                    MATCHER_MAX_STRATEGY - 1);
+            strncpy(results[pos].fix_template, db->signatures[i].fix_template,
+                    MATCHER_MAX_FIX_TEMPLATE - 1);
+            result_count++;
+        } else if (sim > results[k - 1].similarity) {
+            /* Replace the lowest (last) element */
+            int pos = k - 1;
+            while (pos > 0 && results[pos - 1].similarity < sim) {
+                results[pos] = results[pos - 1];
+                pos--;
+            }
+            memset(&results[pos], 0, sizeof(MatchResult));
+            strncpy(results[pos].sig_id, db->signatures[i].sig_id,
+                    MATCHER_MAX_SIG_ID - 1);
+            results[pos].similarity = sim;
+            results[pos].reliability = db->signatures[i].reliability;
+            results[pos].match_count = db->signatures[i].match_count;
+            strncpy(results[pos].resolution_strategy,
+                    db->signatures[i].resolution_strategy,
+                    MATCHER_MAX_STRATEGY - 1);
+            strncpy(results[pos].fix_template, db->signatures[i].fix_template,
+                    MATCHER_MAX_FIX_TEMPLATE - 1);
+        }
+    }
+
+    /* Ensure results are sorted descending */
+    qsort(results, result_count, sizeof(MatchResult), compare_results);
+
+    return result_count;
+}
+
+/* ── Default Config ────────────────────────────────────────── */
+
+MatcherConfig config_default(void) {
+    MatcherConfig c;
+    c.w_error_type = 0.30;
+    c.w_error_message = 0.15;
+    c.w_location = 0.25;
+    c.w_stack_trace = 0.15;
+    c.w_change_context = 0.10;
+    c.w_temporal = 0.05;
+    c.min_confidence = 0.65;
+    c.top_k = 3;
+    return c;
+}

package/signature/src/matcher.h

@@ -0,0 +1,135 @@
+/*
+ * matcher.h — Signature Matching Engine
+ *
+ * Multi-dimensional feature-vector similarity matching for
+ * failure signature identification. Designed for low-latency
+ * lookup (<1ms for <100K signatures) without external dependencies.
+ */
+
+#ifndef MATCHER_H
+#define MATCHER_H
+
+#include <stdint.h>
+
+/* ── Constants ─────────────────────────────────────────────── */
+#define MATCHER_MAX_STACK_DEPTH   10
+#define MATCHER_MAX_LOCATION_LEN  256
+#define MATCHER_MAX_ERROR_TYPE    64
+#define MATCHER_MAX_SIG_ID        32
+#define MATCHER_MAX_STRATEGY      32
+#define MATCHER_MAX_FIX_TEMPLATE  512
+#define MATCHER_MAX_RESULTS       16
+
+/* ── Enums ─────────────────────────────────────────────────── */
+typedef enum {
+    DISTANCE_SAME_FILE = 0,
+    DISTANCE_SAME_MODULE = 1,
+    DISTANCE_DIFFERENT_MODULE = 2
+} DistanceToError;
+
+typedef enum {
+    CHANGE_LOGIC_FIX = 0,
+    CHANGE_NEW_FEATURE = 1,
+    CHANGE_REFACTOR = 2,
+    CHANGE_CONFIG = 3,
+    CHANGE_DEPENDENCY = 4
+} ChangeType;
+
+/* ── Data Structures ───────────────────────────────────────── */
+typedef struct {
+    char error_type[MATCHER_MAX_ERROR_TYPE];
+    uint64_t error_message_hash;
+    char location_pattern[MATCHER_MAX_LOCATION_LEN];
+    int stack_depth;
+    uint64_t stack_hashes[MATCHER_MAX_STACK_DEPTH];
+    int change_type;
+    int distance_to_error;
+    int is_new_in_diff;
+} FeatureVector;
+
+typedef struct {
+    char sig_id[MATCHER_MAX_SIG_ID];
+    FeatureVector features;
+    double reliability;
+    int match_count;
+    char resolution_strategy[MATCHER_MAX_STRATEGY];
+    char fix_template[MATCHER_MAX_FIX_TEMPLATE];
+} Signature;
+
+typedef struct {
+    char sig_id[MATCHER_MAX_SIG_ID];
+    double similarity;
+    double reliability;
+    int match_count;
+    char resolution_strategy[MATCHER_MAX_STRATEGY];
+    char fix_template[MATCHER_MAX_FIX_TEMPLATE];
+} MatchResult;
+
+typedef struct {
+    Signature *signatures;
+    int count;
+    int capacity;
+} SignatureDB;
+
+/* ── Weight Configuration ──────────────────────────────────── */
+typedef struct {
+    double w_error_type;       /* default: 0.30 */
+    double w_error_message;    /* default: 0.15 */
+    double w_location;         /* default: 0.25 */
+    double w_stack_trace;      /* default: 0.15 */
+    double w_change_context;   /* default: 0.10 */
+    double w_temporal;         /* default: 0.05 */
+    double min_confidence;     /* default: 0.65 */
+    int top_k;                 /* default: 3 */
+} MatcherConfig;
+
+/* ── API ───────────────────────────────────────────────────── */
+
+/*
+ * Initialize a new signature database with the given capacity.
+ * Returns NULL on allocation failure.
+ */
+SignatureDB* db_create(int initial_capacity);
+
+/*
+ * Free the signature database and all its signatures.
+ */
+void db_destroy(SignatureDB *db);
+
+/*
+ * Add a signature to the database. Returns 0 on success, -1 if full.
+ */
+int db_add(SignatureDB *db, const Signature *sig);
+
+/*
+ * Match a query feature vector against the database.
+ * Results are written to `results` (caller-allocated, size `k`).
+ * Returns the number of results above min_confidence.
+ */
+int db_match(const SignatureDB *db, const MatcherConfig *config,
+             const FeatureVector *query,
+             MatchResult *results, int k);
+
+/*
+ * Get default matcher configuration.
+ */
+MatcherConfig config_default(void);
+
+/*
+ * Compute similarity between two feature vectors (0.0 to 1.0).
+ */
+double vector_similarity(const MatcherConfig *config,
+                         const FeatureVector *a, const FeatureVector *b);
+
+/*
+ * Hash a normalized error message string for fast comparison.
+ */
+uint64_t hash_error_message(const char *msg);
+
+/*
+ * Extract location pattern from a file:line string.
+ * E.g., "auth/session.py:validate_token" → "auth/session.py"
+ */
+void extract_location_pattern(const char *file_line, char *out, int out_len);
+
+#endif /* MATCHER_H */

package/signatures/seed_signatures.json

@@ -0,0 +1,174 @@
+{
+  "signatures": [
+    {
+      "signature_id": "sig-seed-001",
+      "created_at": "2026-01-01T00:00:00",
+      "last_matched": "2026-01-01T00:00:00",
+      "match_count": 0,
+      "feature_vector": {
+        "error_type": "AttributeError",
+        "error_message_hash": "abc123def456",
+        "error_location_pattern": "",
+        "stack_trace_signature": [],
+        "change_context": {
+          "files_touched": [],
+          "change_types": ["refactor"],
+          "distance_to_error": "SAME_FILE"
+        },
+        "temporal": {
+          "is_new_in_this_diff": true,
+          "frequency_30d": 0
+        }
+      },
+      "diagnosis": {
+        "root_cause": "属性/方法重命名后，调用方未同步更新",
+        "root_cause_category": "refactor",
+        "reliability": 0.7
+      },
+      "resolution": {
+        "strategy": "FIX_AND_RETEST",
+        "fix_template": "检查所有调用方，将旧的属性/方法名更新为新名称",
+        "verification_required": [
+          "搜索旧方法名的所有引用，确认已全部更新",
+          "运行受影响的测试"
+        ]
+      }
+    },
+    {
+      "signature_id": "sig-seed-002",
+      "created_at": "2026-01-01T00:00:00",
+      "last_matched": "2026-01-01T00:00:00",
+      "match_count": 0,
+      "feature_vector": {
+        "error_type": "ImportError",
+        "error_message_hash": "def456ghi789",
+        "error_location_pattern": "",
+        "stack_trace_signature": [],
+        "change_context": {
+          "files_touched": [],
+          "change_types": ["dependency"],
+          "distance_to_error": "SAME_FILE"
+        },
+        "temporal": {
+          "is_new_in_this_diff": true,
+          "frequency_30d": 0
+        }
+      },
+      "diagnosis": {
+        "root_cause": "缺少依赖或依赖版本不兼容",
+        "root_cause_category": "dependency",
+        "reliability": 0.8
+      },
+      "resolution": {
+        "strategy": "FIX_AND_RETEST",
+        "fix_template": "检查并安装缺失的依赖，或锁定到兼容版本",
+        "verification_required": [
+          "确认 requirements.txt 包含所需依赖",
+          "运行 pip install 确认无冲突"
+        ]
+      }
+    },
+    {
+      "signature_id": "sig-seed-003",
+      "created_at": "2026-01-01T00:00:00",
+      "last_matched": "2026-01-01T00:00:00",
+      "match_count": 0,
+      "feature_vector": {
+        "error_type": "AssertionError",
+        "error_message_hash": "ghi789jkl012",
+        "error_location_pattern": "",
+        "stack_trace_signature": [],
+        "change_context": {
+          "files_touched": [],
+          "change_types": ["logic_fix"],
+          "distance_to_error": "SAME_FILE"
+        },
+        "temporal": {
+          "is_new_in_this_diff": true,
+          "frequency_30d": 0
+        }
+      },
+      "diagnosis": {
+        "root_cause": "测试断言值与实际输出不匹配——代码行为改变了但测试预期未更新，或代码逻辑错误",
+        "root_cause_category": "logic_error",
+        "reliability": 0.6
+      },
+      "resolution": {
+        "strategy": "DIAGNOSE_AND_FIX",
+        "fix_template": "对比预期值和实际值，判断是代码逻辑错误还是测试预期需要更新",
+        "verification_required": [
+          "确认实际输出是否符合 Spec 预期",
+          "如果实际输出正确，更新测试；否则修复代码"
+        ]
+      }
+    },
+    {
+      "signature_id": "sig-seed-004",
+      "created_at": "2026-01-01T00:00:00",
+      "last_matched": "2026-01-01T00:00:00",
+      "match_count": 0,
+      "feature_vector": {
+        "error_type": "TypeError",
+        "error_message_hash": "jkl012mno345",
+        "error_location_pattern": "",
+        "stack_trace_signature": [],
+        "change_context": {
+          "files_touched": [],
+          "change_types": ["refactor"],
+          "distance_to_error": "SAME_FILE"
+        },
+        "temporal": {
+          "is_new_in_this_diff": true,
+          "frequency_30d": 0
+        }
+      },
+      "diagnosis": {
+        "root_cause": "函数调用参数类型或数量不匹配——签名变更未同步",
+        "root_cause_category": "refactor",
+        "reliability": 0.75
+      },
+      "resolution": {
+        "strategy": "FIX_AND_RETEST",
+        "fix_template": "检查函数签名变更，确保所有调用方传递正确的参数类型和数量",
+        "verification_required": [
+          "检查所有调用点的参数是否与新签名匹配",
+          "运行类型检查器"
+        ]
+      }
+    },
+    {
+      "signature_id": "sig-seed-005",
+      "created_at": "2026-01-01T00:00:00",
+      "last_matched": "2026-01-01T00:00:00",
+      "match_count": 0,
+      "feature_vector": {
+        "error_type": "KeyError",
+        "error_message_hash": "mno345pqr678",
+        "error_location_pattern": "",
+        "stack_trace_signature": [],
+        "change_context": {
+          "files_touched": [],
+          "change_types": ["config"],
+          "distance_to_error": "SAME_FILE"
+        },
+        "temporal": {
+          "is_new_in_this_diff": true,
+          "frequency_30d": 0
+        }
+      },
+      "diagnosis": {
+        "root_cause": "字典/配置键缺失——需要的配置项未被设置",
+        "root_cause_category": "config",
+        "reliability": 0.7
+      },
+      "resolution": {
+        "strategy": "FIX_AND_RETEST",
+        "fix_template": "确认配置文件中包含所需键，或添加默认值兜底",
+        "verification_required": [
+          "检查所有环境下的配置文件",
+          "添加配置缺失时的降级逻辑"
+        ]
+      }
+    }
+  ]
+}