albert-memory 0.4.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (74) hide show
  1. albert/__init__.py +3 -0
  2. albert/admin.py +532 -0
  3. albert/api.py +698 -0
  4. albert/automatic_memory_release.json +14 -0
  5. albert/benchmark.py +272 -0
  6. albert/benchmark_cli.py +37 -0
  7. albert/capture.py +1051 -0
  8. albert/capture_installer.py +1000 -0
  9. albert/capture_promotion.py +298 -0
  10. albert/capture_retention.py +72 -0
  11. albert/capture_sdk.py +558 -0
  12. albert/capture_security.py +79 -0
  13. albert/chunking.py +79 -0
  14. albert/classifier.py +263 -0
  15. albert/claude_adapter.py +357 -0
  16. albert/claude_lifecycle.py +418 -0
  17. albert/claude_package.json +19 -0
  18. albert/claude_plugin/.claude-plugin/plugin.json +11 -0
  19. albert/claude_plugin/.mcp.json +13 -0
  20. albert/claude_plugin/hooks/hooks.json +70 -0
  21. albert/clusters.py +140 -0
  22. albert/codex_adapter.py +308 -0
  23. albert/codex_hooks/hooks.json +49 -0
  24. albert/codex_lifecycle.py +485 -0
  25. albert/codex_package.json +19 -0
  26. albert/compatibility.py +121 -0
  27. albert/config.py +144 -0
  28. albert/console.py +508 -0
  29. albert/console_backends.py +236 -0
  30. albert/console_map.py +518 -0
  31. albert/console_ops.py +919 -0
  32. albert/credentials.py +616 -0
  33. albert/cursor_adapter.py +320 -0
  34. albert/cursor_hooks/hooks.json +11 -0
  35. albert/cursor_rules/albert-memory.mdc +11 -0
  36. albert/db.py +68 -0
  37. albert/embeddings.py +91 -0
  38. albert/graph.py +623 -0
  39. albert/graph_builders.py +879 -0
  40. albert/graph_cypher.py +669 -0
  41. albert/graph_store.py +376 -0
  42. albert/host_targets/claude-code.json +45 -0
  43. albert/host_targets/codex.json +45 -0
  44. albert/host_targets/openclaw.json +45 -0
  45. albert/host_targets.py +271 -0
  46. albert/links.py +428 -0
  47. albert/mcp_server.py +457 -0
  48. albert/memory_safety.py +111 -0
  49. albert/models.py +611 -0
  50. albert/openclaw_adapter.py +326 -0
  51. albert/openclaw_adapter_trust.json +5 -0
  52. albert/openclaw_package.json +22 -0
  53. albert/openclaw_plugin/index.js +135 -0
  54. albert/openclaw_plugin/openclaw.plugin.json +25 -0
  55. albert/openclaw_plugin/package.json +12 -0
  56. albert/portability.py +291 -0
  57. albert/provenance.py +105 -0
  58. albert/recorder.py +166 -0
  59. albert/release_gate.py +83 -0
  60. albert/schemas.py +617 -0
  61. albert/scope.py +26 -0
  62. albert/search.py +447 -0
  63. albert/security.py +150 -0
  64. albert/services.py +1316 -0
  65. albert/session_context.py +162 -0
  66. albert/trace_feed.py +165 -0
  67. albert/trace_writer.py +131 -0
  68. albert/tracing.py +75 -0
  69. albert/worker.py +202 -0
  70. albert/workspaces.py +256 -0
  71. albert_memory-0.4.0.dist-info/METADATA +554 -0
  72. albert_memory-0.4.0.dist-info/RECORD +74 -0
  73. albert_memory-0.4.0.dist-info/WHEEL +4 -0
  74. albert_memory-0.4.0.dist-info/entry_points.txt +14 -0
@@ -0,0 +1,298 @@
1
+ from __future__ import annotations
2
+
3
+ import hashlib
4
+ import re
5
+ from uuid import UUID
6
+
7
+ from sqlalchemy import select
8
+ from sqlalchemy.orm import Session
9
+
10
+ from albert.memory_safety import apply_memory_safety
11
+ from albert.models import AuditEvent, CaptureCheckpoint, CaptureEvent, Episode, Memory, utcnow
12
+ from albert.recorder import current_recorder
13
+
14
+ _SENSITIVITY = ("public", "internal", "confidential", "restricted")
15
+ _DURABLE_CLASSES = {
16
+ "assistant_outcome",
17
+ "correction",
18
+ "decision",
19
+ "failure_summary",
20
+ "pre_compaction_checkpoint",
21
+ "selected_tool_outcome",
22
+ "user_goal",
23
+ "vcs_checkpoint",
24
+ }
25
+ _CHATTER = re.compile(
26
+ r"^(?:ok(?:ay)?|thanks?|hello|hi|got it|sounds good|working on it|done)[.!\s]*$", re.I
27
+ )
28
+ # A user prompt that only steers the current turn ("thanks, keep going") states
29
+ # nothing worth remembering; anything with its own content is promoted.
30
+ _CONTINUATION = re.compile(
31
+ r"^(?:(?:ok(?:ay)?|thanks?|thank you|great|cool|yes|sure)[,.!\s]+)*(?:please\s+)?"
32
+ r"(?:keep (?:going|working)|continue|carry on|go ahead|proceed)"
33
+ r"(?:\s+(?:on|with)\s+(?:this|that|it)(?:\s+task)?)?[.!\s]*$",
34
+ re.I,
35
+ )
36
+ _PROCEDURE = re.compile(r"\b(?:steps?|procedure|runbook|how to|first.+then)\b", re.I | re.S)
37
+ _LESSON = re.compile(r"\b(?:lesson|learned|root cause|failed because|avoid)\b", re.I)
38
+ _CLAIM_PREFIX = re.compile(r"^(?:correction|decision|fact)\s*:\s*", re.I)
39
+ _CLAIM_SUBJECT = re.compile(
40
+ r"^(.+?)\s+(?:is|are|was|were|should be|must be)\s+\S+", re.I
41
+ )
42
+
43
+
44
+ def _normalized(content: str) -> str:
45
+ return " ".join(content.casefold().split())
46
+
47
+
48
+ def _claim_subject(content: str) -> str | None:
49
+ claim = _CLAIM_PREFIX.sub("", content.strip())
50
+ match = _CLAIM_SUBJECT.match(claim)
51
+ return _normalized(match.group(1)) if match else None
52
+
53
+
54
+ def _memory_type(event: CaptureEvent) -> str:
55
+ if event.event_class == "decision":
56
+ return "decision"
57
+ if event.event_class == "failure_summary" or _LESSON.search(event.content):
58
+ return "lesson"
59
+ if _PROCEDURE.search(event.content):
60
+ return "procedure"
61
+ if event.event_class in {"vcs_checkpoint", "pre_compaction_checkpoint"}:
62
+ return "project_state"
63
+ return "fact"
64
+
65
+
66
+ def _fingerprint(event: CaptureEvent) -> str:
67
+ material = f"{_memory_type(event)}\0{_normalized(event.content)}"
68
+ return hashlib.sha256(material.encode()).hexdigest()
69
+
70
+
71
+ def _durable(event: CaptureEvent) -> bool:
72
+ content = event.content.strip()
73
+ return bool(
74
+ event.event_class in _DURABLE_CLASSES
75
+ and len(content) >= 12
76
+ and not _CHATTER.match(content)
77
+ and not (event.event_class == "user_goal" and _CONTINUATION.match(content))
78
+ )
79
+
80
+
81
+ def _promotion_metadata(
82
+ checkpoint: CaptureCheckpoint, event: CaptureEvent, fingerprint: str
83
+ ) -> dict[str, object]:
84
+ return {
85
+ "automatic_capture_promotion": True,
86
+ "capture_checkpoint_id": str(checkpoint.id),
87
+ "capture_session_id": str(checkpoint.session_id),
88
+ "capture_event_id": str(event.id),
89
+ "capture_event_sequence": event.sequence,
90
+ "capture_event_class": event.event_class,
91
+ "capture_profile_key": event.profile_key,
92
+ "capture_profile_version": event.profile_version,
93
+ "capture_source_trust": event.source_trust,
94
+ "capture_retention_days": event.retention_days,
95
+ "capture_derivative_policy": event.derivative_policy,
96
+ "capture_promotion_fingerprint": fingerprint,
97
+ "provenance": event.provenance,
98
+ }
99
+
100
+
101
+ def _existing_canonical(session: Session, event: CaptureEvent, fingerprint: str) -> Memory | None:
102
+ candidates = session.scalars(
103
+ select(Memory).where(
104
+ Memory.organization_id == event.organization_id,
105
+ Memory.workspace_id == event.workspace_id,
106
+ Memory.owner_principal_id == event.owner_principal_id,
107
+ Memory.status == "active",
108
+ )
109
+ )
110
+ return next(
111
+ (
112
+ memory
113
+ for memory in candidates
114
+ if (memory.metadata_ or {}).get("capture_promotion_fingerprint") == fingerprint
115
+ ),
116
+ None,
117
+ )
118
+
119
+
120
+ def _event_memory(session: Session, event: CaptureEvent) -> Memory | None:
121
+ if event.derived_memory_id is not None:
122
+ memory = session.get(Memory, event.derived_memory_id)
123
+ if memory is not None:
124
+ return memory
125
+ return session.scalar(
126
+ select(Memory).where(Memory.episode_id == event.episode_id, Memory.status == "active")
127
+ )
128
+
129
+
130
+ def _discard_memory(session: Session, event: CaptureEvent, memory: Memory | None) -> None:
131
+ episode = session.get(Episode, event.episode_id) if event.episode_id else None
132
+ if episode is not None:
133
+ episode.extra = {**episode.extra, "capture_promotion_decision": "discard"}
134
+ if memory is not None and memory.status != "deleted":
135
+ from albert.services import _scrub_memory
136
+
137
+ _scrub_memory(session, memory, utcnow())
138
+ event.derived_memory_id = None
139
+
140
+
141
+ def _supersede_previous(session: Session, event: CaptureEvent, memory: Memory) -> None:
142
+ if event.event_class != "correction":
143
+ return
144
+ subject = _claim_subject(event.content)
145
+ if subject is None:
146
+ return
147
+ candidates = session.execute(
148
+ select(Memory, CaptureEvent)
149
+ .join(CaptureEvent, CaptureEvent.derived_memory_id == Memory.id)
150
+ .where(
151
+ CaptureEvent.session_id == event.session_id,
152
+ CaptureEvent.sequence < event.sequence,
153
+ Memory.status == "active",
154
+ Memory.id != memory.id,
155
+ )
156
+ .order_by(CaptureEvent.sequence.desc())
157
+ ).all()
158
+ previous = next(
159
+ (
160
+ candidate_memory
161
+ for candidate_memory, candidate_event in candidates
162
+ if _claim_subject(candidate_event.content) == subject
163
+ ),
164
+ None,
165
+ )
166
+ if previous is None:
167
+ return
168
+ previous.status = "superseded"
169
+ previous.valid_until = event.occurred_at
170
+ previous.metadata_ = {
171
+ **(previous.metadata_ or {}),
172
+ "superseded_by_memory_id": str(memory.id),
173
+ "superseded_at": event.occurred_at.isoformat(),
174
+ "contradiction_flagged": True,
175
+ "contradiction_memory_ids": [str(memory.id)],
176
+ }
177
+ memory.metadata_ = {
178
+ **(memory.metadata_ or {}),
179
+ "supersedes_memory_id": str(previous.id),
180
+ "contradiction_flagged": True,
181
+ "contradiction_memory_ids": [str(previous.id)],
182
+ }
183
+
184
+
185
+ def promote_capture_checkpoint(session: Session, checkpoint_id: UUID) -> None:
186
+ checkpoint = session.get(CaptureCheckpoint, checkpoint_id)
187
+ if checkpoint is None or checkpoint.deleted_at is not None:
188
+ return
189
+ if checkpoint.promotion_status == "complete":
190
+ return
191
+ checkpoint.promotion_status = "running"
192
+ checkpoint.promotion_error = None
193
+ session.commit()
194
+
195
+ checkpoint = session.get(CaptureCheckpoint, checkpoint_id)
196
+ assert checkpoint is not None
197
+ prior_sequence = session.scalar(
198
+ select(CaptureCheckpoint.through_sequence)
199
+ .where(
200
+ CaptureCheckpoint.session_id == checkpoint.session_id,
201
+ CaptureCheckpoint.through_sequence < checkpoint.through_sequence,
202
+ CaptureCheckpoint.deleted_at.is_(None),
203
+ )
204
+ .order_by(CaptureCheckpoint.through_sequence.desc())
205
+ .limit(1)
206
+ ) or 0
207
+ events = list(
208
+ session.scalars(
209
+ select(CaptureEvent)
210
+ .where(
211
+ CaptureEvent.session_id == checkpoint.session_id,
212
+ CaptureEvent.sequence > prior_sequence,
213
+ CaptureEvent.sequence <= checkpoint.through_sequence,
214
+ CaptureEvent.deleted_at.is_(None),
215
+ CaptureEvent.organization_id == checkpoint.organization_id,
216
+ CaptureEvent.workspace_id == checkpoint.workspace_id,
217
+ CaptureEvent.owner_principal_id == checkpoint.owner_principal_id,
218
+ )
219
+ .order_by(CaptureEvent.sequence)
220
+ )
221
+ )
222
+ promoted: list[Memory] = []
223
+ for event in events:
224
+ memory = _event_memory(session, event)
225
+ if not _durable(event):
226
+ _discard_memory(session, event, memory)
227
+ continue
228
+ if memory is None:
229
+ from albert.services import enrich_episode
230
+
231
+ enrich_episode(session, event.episode_id)
232
+ memory = _event_memory(session, event)
233
+ if memory is None:
234
+ raise RuntimeError(f"capture event {event.id} has no derived memory")
235
+ fingerprint = _fingerprint(event)
236
+ canonical = _existing_canonical(session, event, fingerprint)
237
+ if canonical is not None and canonical.id != memory.id:
238
+ _discard_memory(session, event, memory)
239
+ event.derived_memory_id = canonical.id
240
+ promoted.append(canonical)
241
+ continue
242
+ memory.memory_type = _memory_type(event)
243
+ memory.sensitivity = max(
244
+ memory.sensitivity, event.sensitivity, key=_SENSITIVITY.index
245
+ )
246
+ memory.valid_from = event.occurred_at
247
+ memory.metadata_ = {
248
+ **(memory.metadata_ or {}),
249
+ **_promotion_metadata(checkpoint, event, fingerprint),
250
+ }
251
+ memory.confidence, memory.metadata_ = apply_memory_safety(
252
+ memory.content,
253
+ memory.confidence,
254
+ memory.metadata_,
255
+ default_trust=event.source_trust,
256
+ )
257
+ episode = session.get(Episode, event.episode_id) if event.episode_id else None
258
+ if episode is not None:
259
+ episode.extra = {**episode.extra, "capture_promotion_decision": "promote"}
260
+ event.derived_memory_id = memory.id
261
+ _supersede_previous(session, event, memory)
262
+ promoted.append(memory)
263
+
264
+ unique = {memory.id: memory for memory in promoted}
265
+ checkpoint.derived_memory_id = promoted[-1].id if promoted else None
266
+ checkpoint.metadata_ = {
267
+ **checkpoint.metadata_,
268
+ "promoted_memory_ids": [str(memory_id) for memory_id in unique],
269
+ "promoted_count": len(unique),
270
+ "discarded_count": len(events) - len(promoted),
271
+ }
272
+ checkpoint.promotion_status = "complete"
273
+ checkpoint.promotion_error = None
274
+ session.add(
275
+ AuditEvent(
276
+ organization_id=checkpoint.organization_id,
277
+ workspace_id=checkpoint.workspace_id,
278
+ principal_id=checkpoint.owner_principal_id,
279
+ event_type="capture.checkpoint.completed",
280
+ resource_type="capture_checkpoint",
281
+ resource_id=str(checkpoint.id),
282
+ detail={
283
+ "through_sequence": checkpoint.through_sequence,
284
+ "promoted_count": len(unique),
285
+ "discarded_count": len(events) - len(promoted),
286
+ },
287
+ )
288
+ )
289
+ session.commit()
290
+ recorder = current_recorder()
291
+ if recorder is not None:
292
+ recorder.note(
293
+ capture_stage="consolidation",
294
+ checkpoint_id=str(checkpoint.id),
295
+ checkpoint_status="complete",
296
+ promoted_count=len(unique),
297
+ discarded_count=len(events) - len(promoted),
298
+ )
@@ -0,0 +1,72 @@
1
+ from __future__ import annotations
2
+
3
+ from datetime import datetime, timedelta
4
+
5
+ from sqlalchemy import or_, select
6
+ from sqlalchemy.orm import Session
7
+
8
+ from albert.models import CaptureCheckpoint, CaptureEvent, Episode, Memory, utcnow
9
+
10
+
11
+ def _expire_event(session: Session, event: CaptureEvent, now: datetime) -> None:
12
+ if event.deleted_at is not None:
13
+ return
14
+ from albert.services import _scrub_memory, forget_episode_graph
15
+
16
+ memories = list(
17
+ session.scalars(
18
+ select(Memory).where(
19
+ or_(Memory.episode_id == event.episode_id, Memory.id == event.derived_memory_id),
20
+ Memory.status != "deleted",
21
+ )
22
+ )
23
+ )
24
+ for memory in memories:
25
+ _scrub_memory(session, memory, now)
26
+ if event.derivative_policy == "invalidate":
27
+ memory.status = "invalidated"
28
+ episode = session.get(Episode, event.episode_id) if event.episode_id is not None else None
29
+ if episode is not None and episode.deleted_at is None:
30
+ forget_episode_graph(session, episode)
31
+ episode.content = ""
32
+ episode.extra = {}
33
+ episode.enrichment_error = None
34
+ episode.deleted_at = now
35
+ event.content = ""
36
+ event.metadata_ = {}
37
+ event.deleted_at = now
38
+ session.query(CaptureCheckpoint).filter(
39
+ CaptureCheckpoint.session_id == event.session_id,
40
+ CaptureCheckpoint.through_sequence >= event.sequence,
41
+ CaptureCheckpoint.deleted_at.is_(None),
42
+ ).update({CaptureCheckpoint.deleted_at: now}, synchronize_session=False)
43
+
44
+
45
+ def expire_capture_events(session: Session, *, now: datetime | None = None) -> int:
46
+ """Idempotently expire capture records and provenance-linked derivatives."""
47
+ effective_now = now or utcnow()
48
+ events = list(session.scalars(select(CaptureEvent).where(CaptureEvent.deleted_at.is_(None))))
49
+ expired = 0
50
+ for event in events:
51
+ occurred_at = event.occurred_at
52
+ if occurred_at.tzinfo is None and effective_now.tzinfo is not None:
53
+ occurred_at = occurred_at.replace(tzinfo=effective_now.tzinfo)
54
+ if occurred_at + timedelta(days=event.retention_days) <= effective_now:
55
+ _expire_event(session, event, effective_now)
56
+ expired += 1
57
+ return expired
58
+
59
+
60
+ def delete_capture_for_episode(session: Session, episode_id, now: datetime) -> None: # type: ignore[no-untyped-def]
61
+ for event in session.scalars(
62
+ select(CaptureEvent).where(
63
+ CaptureEvent.episode_id == episode_id, CaptureEvent.deleted_at.is_(None)
64
+ )
65
+ ):
66
+ event.content = ""
67
+ event.metadata_ = {}
68
+ event.deleted_at = now
69
+ session.query(CaptureCheckpoint).filter(
70
+ CaptureCheckpoint.episode_id == episode_id,
71
+ CaptureCheckpoint.deleted_at.is_(None),
72
+ ).update({CaptureCheckpoint.deleted_at: now}, synchronize_session=False)