← back to dpopsuev__origami-rca

Function bodies 401 total

All specs Real LLM only Function bodies
ListJobsByLaunch method · go · L184-L190 (7 LOC)
store/memstore_entities.go
func (s *MemStore) ListJobsByLaunch(launchID int64) ([]*Job, error) {
	rows, err := s.mes.List("jobs", sqlite.Row{"launch_id": launchID}, "")
	if err != nil {
		return nil, err
	}
	return rowsTo(rows, jobFromRow), nil
}
CreateCase method · go · L194-L215 (22 LOC)
store/memstore_entities.go
func (s *MemStore) CreateCase(c *Case) (int64, error) {
	if c == nil {
		return 0, fmt.Errorf("case is nil")
	}
	if c.Status == "" {
		c.Status = "open"
	}
	if c.CreatedAt == "" {
		c.CreatedAt = now()
	}
	c.UpdatedAt = now()
	return s.mes.Create("cases", sqlite.Row{
		"job_id": c.JobID, "launch_id": c.LaunchID,
		"source_item_id": c.SourceItemID, "name": c.Name,
		"external_ref": c.ExternalRef, "status": c.Status,
		"symptom_id": c.SymptomID, "rca_id": c.RCAID,
		"error_message": c.ErrorMessage, "log_snippet": c.LogSnippet,
		"log_truncated": boolToInt(c.LogTruncated),
		"started_at": c.StartedAt, "ended_at": c.EndedAt,
		"created_at": c.CreatedAt, "updated_at": c.UpdatedAt,
	})
}
GetCase method · go · L217-L223 (7 LOC)
store/memstore_entities.go
func (s *MemStore) GetCase(id int64) (*Case, error) {
	row, err := s.mes.Get("cases", id)
	if err != nil || row == nil {
		return nil, err
	}
	return caseFromRow(row), nil
}
ListCasesByJob method · go · L225-L231 (7 LOC)
store/memstore_entities.go
func (s *MemStore) ListCasesByJob(jobID int64) ([]*Case, error) {
	rows, err := s.mes.List("cases", sqlite.Row{"job_id": jobID}, "")
	if err != nil {
		return nil, err
	}
	return rowsTo(rows, caseFromRow), nil
}
ListCasesBySymptom method · go · L233-L239 (7 LOC)
store/memstore_entities.go
func (s *MemStore) ListCasesBySymptom(symptomID int64) ([]*Case, error) {
	rows, err := s.mes.List("cases", sqlite.Row{"symptom_id": symptomID}, "")
	if err != nil {
		return nil, err
	}
	return rowsTo(rows, caseFromRow), nil
}
UpdateCaseStatus method · go · L241-L245 (5 LOC)
store/memstore_entities.go
func (s *MemStore) UpdateCaseStatus(caseID int64, status string) error {
	return s.mes.Update("cases", caseID, sqlite.Row{
		"status": status, "updated_at": now(),
	})
}
LinkCaseToRCA method · go · L247-L249 (3 LOC)
store/memstore_entities.go
func (s *MemStore) LinkCaseToRCA(caseID, rcaID int64) error {
	return s.mes.Update("cases", caseID, sqlite.Row{"rca_id": rcaID})
}
Repobility's GitHub App fixes findings like these · https://github.com/apps/repobility-bot
LinkCaseToSymptom method · go · L251-L255 (5 LOC)
store/memstore_entities.go
func (s *MemStore) LinkCaseToSymptom(caseID, symptomID int64) error {
	return s.mes.Update("cases", caseID, sqlite.Row{
		"symptom_id": symptomID, "updated_at": now(),
	})
}
CreateTriage method · go · L259-L275 (17 LOC)
store/memstore_entities.go
func (s *MemStore) CreateTriage(t *Triage) (int64, error) {
	if t == nil {
		return 0, fmt.Errorf("triage is nil")
	}
	if t.CreatedAt == "" {
		t.CreatedAt = now()
	}
	return s.mes.Create("triages", sqlite.Row{
		"case_id": t.CaseID, "symptom_category": t.SymptomCategory,
		"severity": t.Severity, "defect_type_hypothesis": t.DefectTypeHypothesis,
		"skip_investigation": boolToInt(t.SkipInvestigation),
		"clock_skew_suspected": boolToInt(t.ClockSkewSuspected),
		"cascade_suspected": boolToInt(t.CascadeSuspected),
		"candidate_repos": t.CandidateRepos, "data_quality_notes": t.DataQualityNotes,
		"created_at": t.CreatedAt,
	})
}
GetTriageByCase method · go · L277-L283 (7 LOC)
store/memstore_entities.go
func (s *MemStore) GetTriageByCase(caseID int64) (*Triage, error) {
	row, err := s.mes.GetBy("triages", sqlite.Row{"case_id": caseID})
	if err != nil || row == nil {
		return nil, err
	}
	return triageFromRow(row), nil
}
CreateSymptom method · go · L287-L315 (29 LOC)
store/memstore_entities.go
func (s *MemStore) CreateSymptom(sym *Symptom) (int64, error) {
	if sym == nil {
		return 0, fmt.Errorf("symptom is nil")
	}
	existing, _ := s.mes.GetBy("symptoms", sqlite.Row{"fingerprint": sym.Fingerprint})
	if existing != nil {
		return 0, fmt.Errorf("symptom with fingerprint %q already exists", sym.Fingerprint)
	}
	if sym.Status == "" {
		sym.Status = "active"
	}
	if sym.OccurrenceCount == 0 {
		sym.OccurrenceCount = 1
	}
	if sym.FirstSeenAt == "" {
		sym.FirstSeenAt = now()
	}
	if sym.LastSeenAt == "" {
		sym.LastSeenAt = sym.FirstSeenAt
	}
	return s.mes.Create("symptoms", sqlite.Row{
		"fingerprint": sym.Fingerprint, "name": sym.Name,
		"description": sym.Description, "error_pattern": sym.ErrorPattern,
		"test_name_pattern": sym.TestNamePattern, "component": sym.Component,
		"severity": sym.Severity, "first_seen_at": sym.FirstSeenAt,
		"last_seen_at": sym.LastSeenAt, "occurrence_count": sym.OccurrenceCount,
		"status": sym.Status,
	})
}
GetSymptom method · go · L317-L323 (7 LOC)
store/memstore_entities.go
func (s *MemStore) GetSymptom(id int64) (*Symptom, error) {
	row, err := s.mes.Get("symptoms", id)
	if err != nil || row == nil {
		return nil, err
	}
	return symptomFromRow(row), nil
}
GetSymptomByFingerprint method · go · L325-L331 (7 LOC)
store/memstore_entities.go
func (s *MemStore) GetSymptomByFingerprint(fingerprint string) (*Symptom, error) {
	row, err := s.mes.GetBy("symptoms", sqlite.Row{"fingerprint": fingerprint})
	if err != nil || row == nil {
		return nil, err
	}
	return symptomFromRow(row), nil
}
FindSymptomCandidates method · go · L333-L342 (10 LOC)
store/memstore_entities.go
func (s *MemStore) FindSymptomCandidates(testName string) ([]*Symptom, error) {
	if testName == "" {
		return nil, nil
	}
	rows, err := s.mes.List("symptoms", sqlite.Row{"name": testName}, "")
	if err != nil {
		return nil, err
	}
	return rowsTo(rows, symptomFromRow), nil
}
UpdateSymptomSeen method · go · L344-L352 (9 LOC)
store/memstore_entities.go
func (s *MemStore) UpdateSymptomSeen(id int64) error {
	return s.mes.Mutate("symptoms", id, func(r sqlite.Row) {
		r["occurrence_count"] = r.Int64("occurrence_count") + 1
		r["last_seen_at"] = now()
		if r.String("status") == "dormant" {
			r["status"] = "active"
		}
	})
}
Repobility · MCP-ready · https://repobility.com
ListSymptoms method · go · L354-L360 (7 LOC)
store/memstore_entities.go
func (s *MemStore) ListSymptoms() ([]*Symptom, error) {
	rows, err := s.mes.List("symptoms", nil, "")
	if err != nil {
		return nil, err
	}
	return rowsTo(rows, symptomFromRow), nil
}
SnapshotSymptoms method · go · L363-L366 (4 LOC)
store/memstore_entities.go
func (s *MemStore) SnapshotSymptoms() []*Symptom {
	rows, _ := s.mes.List("symptoms", nil, "")
	return rowsTo(rows, symptomFromRow)
}
MarkDormantSymptoms method · go · L368-L377 (10 LOC)
store/memstore_entities.go
func (s *MemStore) MarkDormantSymptoms(staleDays int) (int64, error) {
	cutoff := time.Now().UTC().AddDate(0, 0, -staleDays).Format(time.RFC3339)
	return s.mes.MutateAll("symptoms", func(r sqlite.Row) bool {
		if r.String("status") == "active" && r.String("last_seen_at") < cutoff {
			r["status"] = "dormant"
			return true
		}
		return false
	})
}
SaveRCA method · go · L381-L415 (35 LOC)
store/memstore_entities.go
func (s *MemStore) SaveRCA(rca *RCA) (int64, error) {
	if rca == nil {
		return 0, fmt.Errorf("rca is nil")
	}
	if rca.ID != 0 {
		existing, _ := s.mes.Get("rcas", rca.ID)
		if existing != nil {
			return rca.ID, s.mes.Update("rcas", rca.ID, sqlite.Row{
				"title": rca.Title, "description": rca.Description,
				"defect_type": rca.DefectType, "category": rca.Category,
				"component": rca.Component, "affected_versions": rca.AffectedVersions,
				"evidence_refs": rca.EvidenceRefs, "convergence_score": rca.ConvergenceScore,
				"jira_ticket_id": rca.JiraTicketID, "jira_link": rca.JiraLink,
				"status": rca.Status, "resolved_at": rca.ResolvedAt,
				"verified_at": rca.VerifiedAt, "archived_at": rca.ArchivedAt,
			})
		}
	}
	if rca.Status == "" {
		rca.Status = "open"
	}
	if rca.CreatedAt == "" {
		rca.CreatedAt = now()
	}
	return s.mes.Create("rcas", sqlite.Row{
		"title": rca.Title, "description": rca.Description,
		"defect_type": rca.DefectType, "category": rca.Category,
		"component":
GetRCA method · go · L417-L423 (7 LOC)
store/memstore_entities.go
func (s *MemStore) GetRCA(id int64) (*RCA, error) {
	row, err := s.mes.Get("rcas", id)
	if err != nil || row == nil {
		return nil, err
	}
	return rcaFromRow(row), nil
}
ListRCAs method · go · L425-L431 (7 LOC)
store/memstore_entities.go
func (s *MemStore) ListRCAs() ([]*RCA, error) {
	rows, err := s.mes.List("rcas", nil, "")
	if err != nil {
		return nil, err
	}
	return rowsTo(rows, rcaFromRow), nil
}
ListRCAsByStatus method · go · L433-L439 (7 LOC)
store/memstore_entities.go
func (s *MemStore) ListRCAsByStatus(status string) ([]*RCA, error) {
	rows, err := s.mes.List("rcas", sqlite.Row{"status": status}, "")
	if err != nil {
		return nil, err
	}
	return rowsTo(rows, rcaFromRow), nil
}
UpdateRCAStatus method · go · L441-L455 (15 LOC)
store/memstore_entities.go
func (s *MemStore) UpdateRCAStatus(id int64, status string) error {
	set := sqlite.Row{"status": status}
	switch status {
	case "resolved":
		set["resolved_at"] = now()
	case "verified":
		set["verified_at"] = now()
	case "archived":
		set["archived_at"] = now()
	case "open":
		set["resolved_at"] = ""
		set["verified_at"] = ""
	}
	return s.mes.Update("rcas", id, set)
}
Open data scored by Repobility · https://repobility.com
LinkSymptomToRCA method · go · L459-L478 (20 LOC)
store/memstore_entities.go
func (s *MemStore) LinkSymptomToRCA(link *SymptomRCA) (int64, error) {
	if link == nil {
		return 0, fmt.Errorf("link is nil")
	}
	// Check for duplicate
	rows, _ := s.mes.List("symptom_rca", sqlite.Row{
		"symptom_id": link.SymptomID, "rca_id": link.RCAID,
	}, "")
	if len(rows) > 0 {
		return 0, fmt.Errorf("symptom-rca link already exists")
	}
	if link.LinkedAt == "" {
		link.LinkedAt = now()
	}
	return s.mes.Create("symptom_rca", sqlite.Row{
		"symptom_id": link.SymptomID, "rca_id": link.RCAID,
		"confidence": link.Confidence, "notes": link.Notes,
		"linked_at": link.LinkedAt,
	})
}
GetRCAsForSymptom method · go · L480-L486 (7 LOC)
store/memstore_entities.go
func (s *MemStore) GetRCAsForSymptom(symptomID int64) ([]*SymptomRCA, error) {
	rows, err := s.mes.List("symptom_rca", sqlite.Row{"symptom_id": symptomID}, "")
	if err != nil {
		return nil, err
	}
	return rowsTo(rows, symptomRCAFromRow), nil
}
GetSymptomsForRCA method · go · L488-L494 (7 LOC)
store/memstore_entities.go
func (s *MemStore) GetSymptomsForRCA(rcaID int64) ([]*SymptomRCA, error) {
	rows, err := s.mes.List("symptom_rca", sqlite.Row{"rca_id": rcaID}, "")
	if err != nil {
		return nil, err
	}
	return rowsTo(rows, symptomRCAFromRow), nil
}
NewMemStore function · go · L21-L27 (7 LOC)
store/memstore.go
func NewMemStore() *MemStore {
	schema, _ := LoadSchema()
	return &MemStore{
		envelopes: make(map[string]*rcatype.Envelope),
		mes:       sqlite.NewMemEntityStore(schema),
	}
}
NewMemStoreWithSchema function · go · L30-L39 (10 LOC)
store/memstore.go
func NewMemStoreWithSchema(schemaData []byte) (*MemStore, error) {
	schema, err := sqlite.ParseSchema(schemaData)
	if err != nil {
		return nil, fmt.Errorf("parse schema: %w", err)
	}
	return &MemStore{
		envelopes: make(map[string]*rcatype.Envelope),
		mes:       sqlite.NewMemEntityStore(schema),
	}, nil
}
SaveEnvelope method · go · L45-L53 (9 LOC)
store/memstore.go
func (s *MemStore) SaveEnvelope(runID string, env *rcatype.Envelope) error {
	if env == nil {
		return errors.New("envelope is nil")
	}
	s.mu.Lock()
	defer s.mu.Unlock()
	s.envelopes[runID] = env
	return nil
}
GetEnvelope method · go · L56-L60 (5 LOC)
store/memstore.go
func (s *MemStore) GetEnvelope(runID string) (*rcatype.Envelope, error) {
	s.mu.Lock()
	defer s.mu.Unlock()
	return s.envelopes[runID], nil
}
LoadSchema function · go · L15-L17 (3 LOC)
store/schema.go
func LoadSchema() (*sqlite.Schema, error) {
	return sqlite.ParseSchema(schemaData)
}
Repobility · open methodology · https://repobility.com/research/
suiteFromRow function · go · L11-L16 (6 LOC)
store/sqlstore_entities.go
func suiteFromRow(r sqlite.Row) *InvestigationSuite {
	return &InvestigationSuite{
		ID: r.Int64("id"), Name: r.String("name"), Description: r.String("description"),
		Status: r.String("status"), CreatedAt: r.String("created_at"), ClosedAt: r.String("closed_at"),
	}
}
versionFromRow function · go · L18-L20 (3 LOC)
store/sqlstore_entities.go
func versionFromRow(r sqlite.Row) *Version {
	return &Version{ID: r.Int64("id"), Label: r.String("label"), BuildID: r.String("build_id")}
}
circuitFromRow function · go · L22-L28 (7 LOC)
store/sqlstore_entities.go
func circuitFromRow(r sqlite.Row) *Circuit {
	return &Circuit{
		ID: r.Int64("id"), SuiteID: r.Int64("suite_id"), VersionID: r.Int64("version_id"),
		Name: r.String("name"), SourceRunID: r.String("source_run_id"), Status: r.String("status"),
		StartedAt: r.String("started_at"), EndedAt: r.String("ended_at"),
	}
}
launchFromRow function · go · L30-L39 (10 LOC)
store/sqlstore_entities.go
func launchFromRow(r sqlite.Row) *Launch {
	return &Launch{
		ID: r.Int64("id"), CircuitID: r.Int64("circuit_id"),
		SourceRunID: r.String("source_run_id"), SourceRunUUID: r.String("source_run_uuid"),
		Name: r.String("name"), Status: r.String("status"),
		StartedAt: r.String("started_at"), EndedAt: r.String("ended_at"),
		EnvAttributes: r.String("env_attributes"), GitBranch: r.String("git_branch"),
		GitCommit: r.String("git_commit"), EnvelopePayload: r.Bytes("envelope_payload"),
	}
}
jobFromRow function · go · L41-L50 (10 LOC)
store/sqlstore_entities.go
func jobFromRow(r sqlite.Row) *Job {
	return &Job{
		ID: r.Int64("id"), LaunchID: r.Int64("launch_id"),
		SourceItemID: r.String("source_item_id"), Name: r.String("name"),
		ClockType: r.String("clock_type"), Status: r.String("status"),
		StatsTotal: r.Int("stats_total"), StatsFailed: r.Int("stats_failed"),
		StatsPassed: r.Int("stats_passed"), StatsSkipped: r.Int("stats_skipped"),
		StartedAt: r.String("started_at"), EndedAt: r.String("ended_at"),
	}
}
caseFromRow function · go · L52-L63 (12 LOC)
store/sqlstore_entities.go
func caseFromRow(r sqlite.Row) *Case {
	return &Case{
		ID: r.Int64("id"), JobID: r.Int64("job_id"), LaunchID: r.Int64("launch_id"),
		SourceItemID: r.String("source_item_id"), Name: r.String("name"),
		ExternalRef: r.String("external_ref"), Status: r.String("status"),
		SymptomID: r.Int64("symptom_id"), RCAID: r.Int64("rca_id"),
		ErrorMessage: r.String("error_message"), LogSnippet: r.String("log_snippet"),
		LogTruncated: r.Bool("log_truncated"),
		StartedAt: r.String("started_at"), EndedAt: r.String("ended_at"),
		CreatedAt: r.String("created_at"), UpdatedAt: r.String("updated_at"),
	}
}
triageFromRow function · go · L65-L76 (12 LOC)
store/sqlstore_entities.go
func triageFromRow(r sqlite.Row) *Triage {
	return &Triage{
		ID: r.Int64("id"), CaseID: r.Int64("case_id"),
		SymptomCategory: r.String("symptom_category"), Severity: r.String("severity"),
		DefectTypeHypothesis: r.String("defect_type_hypothesis"),
		SkipInvestigation: r.Bool("skip_investigation"),
		ClockSkewSuspected: r.Bool("clock_skew_suspected"),
		CascadeSuspected: r.Bool("cascade_suspected"),
		CandidateRepos: r.String("candidate_repos"), DataQualityNotes: r.String("data_quality_notes"),
		CreatedAt: r.String("created_at"),
	}
}
symptomFromRow function · go · L78-L87 (10 LOC)
store/sqlstore_entities.go
func symptomFromRow(r sqlite.Row) *Symptom {
	return &Symptom{
		ID: r.Int64("id"), Fingerprint: r.String("fingerprint"), Name: r.String("name"),
		Description: r.String("description"), ErrorPattern: r.String("error_pattern"),
		TestNamePattern: r.String("test_name_pattern"), Component: r.String("component"),
		Severity: r.String("severity"), FirstSeenAt: r.String("first_seen_at"),
		LastSeenAt: r.String("last_seen_at"), OccurrenceCount: r.Int("occurrence_count"),
		Status: r.String("status"),
	}
}
Repobility's GitHub App fixes findings like these · https://github.com/apps/repobility-bot
rcaFromRow function · go · L89-L100 (12 LOC)
store/sqlstore_entities.go
func rcaFromRow(r sqlite.Row) *RCA {
	return &RCA{
		ID: r.Int64("id"), Title: r.String("title"), Description: r.String("description"),
		DefectType: r.String("defect_type"), Category: r.String("category"),
		Component: r.String("component"), AffectedVersions: r.String("affected_versions"),
		EvidenceRefs: r.String("evidence_refs"), ConvergenceScore: r.Float64("convergence_score"),
		JiraTicketID: r.String("jira_ticket_id"), JiraLink: r.String("jira_link"),
		Status: r.String("status"), CreatedAt: r.String("created_at"),
		ResolvedAt: r.String("resolved_at"), VerifiedAt: r.String("verified_at"),
		ArchivedAt: r.String("archived_at"),
	}
}
symptomRCAFromRow function · go · L102-L108 (7 LOC)
store/sqlstore_entities.go
func symptomRCAFromRow(r sqlite.Row) *SymptomRCA {
	return &SymptomRCA{
		ID: r.Int64("id"), SymptomID: r.Int64("symptom_id"), RCAID: r.Int64("rca_id"),
		Confidence: r.Float64("confidence"), Notes: r.String("notes"),
		LinkedAt: r.String("linked_at"),
	}
}
nilIfEmpty function · go · L120-L125 (6 LOC)
store/sqlstore_entities.go
func nilIfEmpty(s string) any {
	if s == "" {
		return nil
	}
	return s
}
nilIfZero function · go · L127-L132 (6 LOC)
store/sqlstore_entities.go
func nilIfZero(n int) any {
	if n == 0 {
		return nil
	}
	return n
}
nilIfZero64 function · go · L134-L139 (6 LOC)
store/sqlstore_entities.go
func nilIfZero64(n int64) any {
	if n == 0 {
		return nil
	}
	return n
}
boolToInt function · go · L141-L146 (6 LOC)
store/sqlstore_entities.go
func boolToInt(b bool) int {
	if b {
		return 1
	}
	return 0
}
CreateSuite method · go · L150-L164 (15 LOC)
store/sqlstore_entities.go
func (s *SqlStore) CreateSuite(suite *InvestigationSuite) (int64, error) {
	if suite == nil {
		return 0, fmt.Errorf("suite is nil")
	}
	if suite.Status == "" {
		suite.Status = "open"
	}
	if suite.CreatedAt == "" {
		suite.CreatedAt = nowUTC()
	}
	return s.es.Create("investigation_suites", sqlite.Row{
		"name": suite.Name, "description": nilIfEmpty(suite.Description),
		"status": suite.Status, "created_at": suite.CreatedAt, "closed_at": nilIfEmpty(suite.ClosedAt),
	})
}
GetSuite method · go · L166-L172 (7 LOC)
store/sqlstore_entities.go
func (s *SqlStore) GetSuite(id int64) (*InvestigationSuite, error) {
	row, err := s.es.Get("investigation_suites", id)
	if err != nil || row == nil {
		return nil, err
	}
	return suiteFromRow(row), nil
}
Repobility · MCP-ready · https://repobility.com
ListSuites method · go · L174-L180 (7 LOC)
store/sqlstore_entities.go
func (s *SqlStore) ListSuites() ([]*InvestigationSuite, error) {
	rows, err := s.es.List("investigation_suites", nil, "")
	if err != nil {
		return nil, err
	}
	return rowsTo(rows, suiteFromRow), nil
}
CloseSuite method · go · L182-L186 (5 LOC)
store/sqlstore_entities.go
func (s *SqlStore) CloseSuite(id int64) error {
	return s.es.Update("investigation_suites", id, sqlite.Row{
		"status": "closed", "closed_at": nowUTC(),
	})
}
CreateVersion method · go · L190-L197 (8 LOC)
store/sqlstore_entities.go
func (s *SqlStore) CreateVersion(v *Version) (int64, error) {
	if v == nil {
		return 0, fmt.Errorf("version is nil")
	}
	return s.es.Create("versions", sqlite.Row{
		"label": v.Label, "build_id": nilIfEmpty(v.BuildID),
	})
}
‹ prevpage 6 / 9next ›