@designerbyron/lifecode-rag 0.0.0-stage → 1.0.0
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.
- package/LICENSE +21 -0
- package/README.md +191 -2
- package/bin/lifecode-rag.mjs +449 -0
- package/client.js +2801 -0
- package/cordis.patch.yml +3 -0
- package/docs/ARCHITECTURE-v0.2.md +269 -0
- package/docs/AUTO-DISCOVERY.md +111 -0
- package/docs/AUTOMATION-POLICIES.md +232 -0
- package/docs/CONTRATO-v0.1.md +195 -0
- package/docs/EMBEDDING-PROVIDERS.md +105 -0
- package/docs/OBSERVABILITY.md +241 -0
- package/docs/PA-UI-0-API-CONTRACT.md +802 -0
- package/docs/PERFORMANCE-BUDGETS.md +118 -0
- package/docs/PROJECT-AWARE-ARCHITECTURE.md +580 -0
- package/docs/PROJECT-AWARE-DATA-CONTRACT.md +411 -0
- package/docs/PROJECT-AWARE-ERROR-CONTRACT.md +112 -0
- package/docs/PROJECT-AWARE-SESSION-CONTRACT.md +120 -0
- package/docs/WORKSPACE-API.md +239 -0
- package/icon.svg +7 -0
- package/index.js +198 -0
- package/lib/audit-export.mjs +70 -0
- package/lib/audit.mjs +120 -0
- package/lib/auto-context.mjs +322 -0
- package/lib/automation.mjs +214 -0
- package/lib/chunk.mjs +100 -0
- package/lib/config-resolve.mjs +119 -0
- package/lib/context.mjs +150 -0
- package/lib/conversation-events.mjs +145 -0
- package/lib/db.mjs +309 -0
- package/lib/diagnose.mjs +197 -0
- package/lib/discovery.mjs +402 -0
- package/lib/doctor.mjs +82 -0
- package/lib/embed.mjs +96 -0
- package/lib/embedders.mjs +103 -0
- package/lib/errors.mjs +227 -0
- package/lib/exec-context.mjs +238 -0
- package/lib/extract.mjs +260 -0
- package/lib/harness-workspaces.mjs +85 -0
- package/lib/hash.mjs +34 -0
- package/lib/ingest.mjs +239 -0
- package/lib/inputs.mjs +67 -0
- package/lib/library-state.mjs +252 -0
- package/lib/maintenance.mjs +113 -0
- package/lib/metrics.mjs +164 -0
- package/lib/migrate.mjs +373 -0
- package/lib/operations.mjs +132 -0
- package/lib/pa-api.mjs +517 -0
- package/lib/paths.mjs +345 -0
- package/lib/policy.mjs +125 -0
- package/lib/profile.mjs +128 -0
- package/lib/readmodel.mjs +159 -0
- package/lib/recovery.mjs +557 -0
- package/lib/registry-schema.mjs +206 -0
- package/lib/registry.mjs +406 -0
- package/lib/resolve.mjs +311 -0
- package/lib/retention.mjs +143 -0
- package/lib/revocation.mjs +124 -0
- package/lib/roots-structure.mjs +224 -0
- package/lib/schema.mjs +173 -0
- package/lib/scope-ops.mjs +379 -0
- package/lib/scope-stores.mjs +128 -0
- package/lib/search.mjs +345 -0
- package/lib/selection.mjs +150 -0
- package/lib/server.mjs +335 -0
- package/lib/session-identity.mjs +51 -0
- package/lib/sessions.mjs +343 -0
- package/lib/sync-scheduler.mjs +354 -0
- package/lib/sync.mjs +755 -0
- package/lib/tags.mjs +45 -0
- package/lib/tools.mjs +364 -0
- package/lib/trusted-roots.mjs +149 -0
- package/lib/worker-context.mjs +22 -0
- package/package.json +67 -5
|
@@ -0,0 +1,206 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* DDL del registro Project-Aware (PA1). Es la traducción literal del contrato de datos
|
|
3
|
+
* `docs/PROJECT-AWARE-DATA-CONTRACT.md` §3. Cualquier cambio aquí debe reflejarse allí y en
|
|
4
|
+
* `eval/pa0/sql-check.mjs`.
|
|
5
|
+
*/
|
|
6
|
+
|
|
7
|
+
export const REGISTRY_APPLICATION_ID = 1_279_480_402; // 'LCRR'
|
|
8
|
+
/** v2: añade `pa_selection` (selección de proyecto persistida con revisión monotónica, CR-1). */
|
|
9
|
+
export const REGISTRY_VERSION = 2;
|
|
10
|
+
|
|
11
|
+
export const REGISTRY_DDL = Object.freeze([
|
|
12
|
+
`CREATE TABLE meta (key TEXT PRIMARY KEY, value TEXT NOT NULL) STRICT`,
|
|
13
|
+
|
|
14
|
+
`CREATE TABLE projects (
|
|
15
|
+
id TEXT PRIMARY KEY
|
|
16
|
+
CHECK (substr(id,1,4)='prj_' AND length(id)=30
|
|
17
|
+
AND substr(id,5) NOT GLOB '*[^0-9A-HJKMNP-TV-Z]*'),
|
|
18
|
+
name TEXT NOT NULL CHECK (length(trim(name)) BETWEEN 1 AND 120),
|
|
19
|
+
status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active','archived')),
|
|
20
|
+
created_at TEXT NOT NULL,
|
|
21
|
+
updated_at TEXT NOT NULL,
|
|
22
|
+
archived_at TEXT,
|
|
23
|
+
CHECK ((status='archived') = (archived_at IS NOT NULL))
|
|
24
|
+
) STRICT`,
|
|
25
|
+
|
|
26
|
+
`CREATE TABLE libraries (
|
|
27
|
+
id TEXT PRIMARY KEY
|
|
28
|
+
CHECK (substr(id,1,4)='lib_' AND length(id)=30
|
|
29
|
+
AND substr(id,5) NOT GLOB '*[^0-9A-HJKMNP-TV-Z]*'),
|
|
30
|
+
name TEXT NOT NULL CHECK (length(trim(name)) BETWEEN 1 AND 120),
|
|
31
|
+
status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active','archived')),
|
|
32
|
+
created_at TEXT NOT NULL,
|
|
33
|
+
updated_at TEXT NOT NULL,
|
|
34
|
+
archived_at TEXT,
|
|
35
|
+
CHECK ((status='archived') = (archived_at IS NOT NULL))
|
|
36
|
+
) STRICT`,
|
|
37
|
+
|
|
38
|
+
`CREATE TABLE roots (
|
|
39
|
+
id TEXT PRIMARY KEY
|
|
40
|
+
CHECK (substr(id,1,3)='rt_' AND length(id)=29
|
|
41
|
+
AND substr(id,4) NOT GLOB '*[^0-9A-HJKMNP-TV-Z]*'),
|
|
42
|
+
scope_kind TEXT NOT NULL CHECK (scope_kind IN ('prj','lib')),
|
|
43
|
+
scope_id TEXT NOT NULL,
|
|
44
|
+
path TEXT NOT NULL CHECK (length(path) > 0),
|
|
45
|
+
path_key TEXT NOT NULL UNIQUE,
|
|
46
|
+
state TEXT NOT NULL DEFAULT 'authorized' CHECK (state IN ('authorized','revoked')),
|
|
47
|
+
added_at TEXT NOT NULL,
|
|
48
|
+
added_by TEXT NOT NULL CHECK (added_by IN ('human','host')),
|
|
49
|
+
revoked_at TEXT,
|
|
50
|
+
CHECK ((state='revoked') = (revoked_at IS NOT NULL)),
|
|
51
|
+
CHECK ((scope_kind='prj' AND substr(scope_id,1,4)='prj_')
|
|
52
|
+
OR (scope_kind='lib' AND substr(scope_id,1,4)='lib_')),
|
|
53
|
+
UNIQUE (id, scope_kind, scope_id)
|
|
54
|
+
) STRICT`,
|
|
55
|
+
|
|
56
|
+
`CREATE TRIGGER roots_scope_insert BEFORE INSERT ON roots
|
|
57
|
+
WHEN (NEW.scope_kind='prj' AND NOT EXISTS (SELECT 1 FROM projects WHERE id=NEW.scope_id))
|
|
58
|
+
OR (NEW.scope_kind='lib' AND NOT EXISTS (SELECT 1 FROM libraries WHERE id=NEW.scope_id))
|
|
59
|
+
BEGIN SELECT RAISE(ABORT,'root-scope-missing'); END`,
|
|
60
|
+
|
|
61
|
+
`CREATE TRIGGER roots_scope_immutable BEFORE UPDATE OF scope_kind, scope_id ON roots
|
|
62
|
+
BEGIN SELECT RAISE(ABORT,'root-scope-immutable'); END`,
|
|
63
|
+
|
|
64
|
+
`CREATE TRIGGER projects_roots_guard BEFORE DELETE ON projects
|
|
65
|
+
WHEN EXISTS (SELECT 1 FROM roots WHERE scope_kind='prj' AND scope_id=OLD.id)
|
|
66
|
+
BEGIN SELECT RAISE(ABORT,'scope-has-roots'); END`,
|
|
67
|
+
|
|
68
|
+
`CREATE TRIGGER libraries_roots_guard BEFORE DELETE ON libraries
|
|
69
|
+
WHEN EXISTS (SELECT 1 FROM roots WHERE scope_kind='lib' AND scope_id=OLD.id)
|
|
70
|
+
BEGIN SELECT RAISE(ABORT,'scope-has-roots'); END`,
|
|
71
|
+
|
|
72
|
+
`CREATE TABLE grants (
|
|
73
|
+
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
74
|
+
project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
|
|
75
|
+
library_id TEXT NOT NULL REFERENCES libraries(id) ON DELETE CASCADE,
|
|
76
|
+
permission TEXT NOT NULL DEFAULT 'read' CHECK (permission='read'),
|
|
77
|
+
granted_at TEXT NOT NULL,
|
|
78
|
+
granted_by TEXT NOT NULL CHECK (granted_by IN ('human','host')),
|
|
79
|
+
revoked_at TEXT,
|
|
80
|
+
revoked_by TEXT,
|
|
81
|
+
CHECK ((revoked_at IS NULL) = (revoked_by IS NULL))
|
|
82
|
+
) STRICT`,
|
|
83
|
+
|
|
84
|
+
`CREATE UNIQUE INDEX grants_one_open ON grants(project_id, library_id) WHERE revoked_at IS NULL`,
|
|
85
|
+
|
|
86
|
+
`CREATE TABLE session_scope (
|
|
87
|
+
session_id TEXT PRIMARY KEY
|
|
88
|
+
CHECK (length(session_id) BETWEEN 1 AND 200 AND session_id NOT GLOB '*[^ -~]*'),
|
|
89
|
+
project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE RESTRICT,
|
|
90
|
+
state TEXT NOT NULL DEFAULT 'active'
|
|
91
|
+
CHECK (state IN ('active','expired','invalidated')),
|
|
92
|
+
selection_source TEXT NOT NULL CHECK (selection_source IN ('explicit','cwd')),
|
|
93
|
+
selected_by TEXT NOT NULL CHECK (selected_by IN ('human','host')),
|
|
94
|
+
selected_at TEXT NOT NULL,
|
|
95
|
+
updated_at TEXT NOT NULL,
|
|
96
|
+
expires_at TEXT,
|
|
97
|
+
invalidated_at TEXT,
|
|
98
|
+
invalid_reason TEXT CHECK (invalid_reason IS NULL OR invalid_reason IN
|
|
99
|
+
('project-archived','grant-revoked','root-revoked','profile-changed',
|
|
100
|
+
'admin','session-cloned')),
|
|
101
|
+
cwd TEXT,
|
|
102
|
+
clone_of TEXT,
|
|
103
|
+
revision INTEGER NOT NULL DEFAULT 1 CHECK (revision >= 1),
|
|
104
|
+
CHECK (state <> 'active' OR (invalidated_at IS NULL AND invalid_reason IS NULL)),
|
|
105
|
+
CHECK (state <> 'expired' OR (expires_at IS NOT NULL AND invalidated_at IS NULL
|
|
106
|
+
AND invalid_reason IS NULL)),
|
|
107
|
+
CHECK (state <> 'invalidated' OR (invalidated_at IS NOT NULL AND invalid_reason IS NOT NULL
|
|
108
|
+
AND expires_at IS NULL))
|
|
109
|
+
) STRICT`,
|
|
110
|
+
|
|
111
|
+
`CREATE TABLE pa_selection (
|
|
112
|
+
selection_key TEXT PRIMARY KEY CHECK (selection_key='profile'),
|
|
113
|
+
project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
|
|
114
|
+
revision INTEGER NOT NULL CHECK (revision >= 1),
|
|
115
|
+
selection_source TEXT NOT NULL CHECK (selection_source IN ('explicit','cwd')),
|
|
116
|
+
selected_by TEXT NOT NULL CHECK (selected_by IN ('human','host')),
|
|
117
|
+
principal TEXT NOT NULL DEFAULT 'owner',
|
|
118
|
+
selected_at TEXT NOT NULL,
|
|
119
|
+
updated_at TEXT NOT NULL
|
|
120
|
+
) STRICT`,
|
|
121
|
+
|
|
122
|
+
`CREATE TABLE sync_state (
|
|
123
|
+
scope_kind TEXT NOT NULL CHECK (scope_kind IN ('prj','lib')),
|
|
124
|
+
scope_id TEXT NOT NULL,
|
|
125
|
+
root_id TEXT NOT NULL,
|
|
126
|
+
source_key TEXT NOT NULL,
|
|
127
|
+
status TEXT NOT NULL CHECK (status IN ('present','missing','unreadable')),
|
|
128
|
+
last_seen_at TEXT,
|
|
129
|
+
last_hash TEXT,
|
|
130
|
+
missing_since TEXT,
|
|
131
|
+
error_code TEXT,
|
|
132
|
+
updated_at TEXT NOT NULL,
|
|
133
|
+
PRIMARY KEY (scope_kind, scope_id, root_id, source_key),
|
|
134
|
+
CHECK ((scope_kind='prj' AND substr(scope_id,1,4)='prj_')
|
|
135
|
+
OR (scope_kind='lib' AND substr(scope_id,1,4)='lib_')),
|
|
136
|
+
FOREIGN KEY (root_id, scope_kind, scope_id)
|
|
137
|
+
REFERENCES roots(id, scope_kind, scope_id) ON DELETE CASCADE
|
|
138
|
+
) STRICT`,
|
|
139
|
+
|
|
140
|
+
`CREATE TABLE audit_registry (
|
|
141
|
+
seq INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
142
|
+
at TEXT NOT NULL,
|
|
143
|
+
actor TEXT NOT NULL CHECK (actor IN ('human','host','model','automation')),
|
|
144
|
+
session_id TEXT,
|
|
145
|
+
action TEXT NOT NULL,
|
|
146
|
+
target TEXT NOT NULL,
|
|
147
|
+
outcome TEXT NOT NULL CHECK (outcome IN ('ok','failed','denied','skipped')),
|
|
148
|
+
detail TEXT,
|
|
149
|
+
prev_hash TEXT NOT NULL,
|
|
150
|
+
hash TEXT NOT NULL
|
|
151
|
+
) STRICT`,
|
|
152
|
+
|
|
153
|
+
`CREATE TABLE operations (
|
|
154
|
+
id TEXT PRIMARY KEY
|
|
155
|
+
CHECK (substr(id,1,3)='op_' AND length(id)=29
|
|
156
|
+
AND substr(id,4) NOT GLOB '*[^0-9A-HJKMNP-TV-Z]*'),
|
|
157
|
+
kind TEXT NOT NULL,
|
|
158
|
+
state TEXT NOT NULL CHECK (state IN ('started','committed','failed','reconciled')),
|
|
159
|
+
started_at TEXT NOT NULL,
|
|
160
|
+
finished_at TEXT,
|
|
161
|
+
detail TEXT,
|
|
162
|
+
CHECK ((state IN ('committed','failed','reconciled')) = (finished_at IS NOT NULL))
|
|
163
|
+
) STRICT`,
|
|
164
|
+
|
|
165
|
+
`CREATE TABLE operation_steps (
|
|
166
|
+
operation_id TEXT NOT NULL REFERENCES operations(id) ON DELETE CASCADE,
|
|
167
|
+
step TEXT NOT NULL,
|
|
168
|
+
state TEXT NOT NULL CHECK (state IN ('pending','done','failed')),
|
|
169
|
+
effect_key TEXT,
|
|
170
|
+
updated_at TEXT NOT NULL,
|
|
171
|
+
PRIMARY KEY (operation_id, step)
|
|
172
|
+
) STRICT`,
|
|
173
|
+
|
|
174
|
+
`CREATE UNIQUE INDEX operation_steps_effect
|
|
175
|
+
ON operation_steps(operation_id, effect_key) WHERE effect_key IS NOT NULL`,
|
|
176
|
+
|
|
177
|
+
`CREATE INDEX projects_status ON projects(status)`,
|
|
178
|
+
`CREATE INDEX roots_scope ON roots(scope_kind, scope_id, state)`,
|
|
179
|
+
`CREATE INDEX grants_project_open ON grants(project_id) WHERE revoked_at IS NULL`,
|
|
180
|
+
`CREATE INDEX session_scope_project ON session_scope(project_id, state)`,
|
|
181
|
+
`CREATE INDEX session_scope_expiry ON session_scope(state, expires_at)`,
|
|
182
|
+
`CREATE INDEX pa_selection_project ON pa_selection(project_id)`,
|
|
183
|
+
`CREATE INDEX sync_state_status ON sync_state(scope_kind, scope_id, status)`,
|
|
184
|
+
`CREATE INDEX audit_registry_at ON audit_registry(at)`,
|
|
185
|
+
]);
|
|
186
|
+
|
|
187
|
+
/**
|
|
188
|
+
* Migraciones aditivas del registro, por versión de destino. Sólo crean estructuras nuevas: ninguna
|
|
189
|
+
* toca filas existentes, así que un registro v1 se abre y sigue sirviendo con los mismos datos.
|
|
190
|
+
* La versión se fija con `PRAGMA user_version` y `meta.registry_version` en la misma transacción.
|
|
191
|
+
*/
|
|
192
|
+
export const REGISTRY_MIGRATIONS = Object.freeze({
|
|
193
|
+
2: Object.freeze([
|
|
194
|
+
`CREATE TABLE IF NOT EXISTS pa_selection (
|
|
195
|
+
selection_key TEXT PRIMARY KEY CHECK (selection_key='profile'),
|
|
196
|
+
project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
|
|
197
|
+
revision INTEGER NOT NULL CHECK (revision >= 1),
|
|
198
|
+
selection_source TEXT NOT NULL CHECK (selection_source IN ('explicit','cwd')),
|
|
199
|
+
selected_by TEXT NOT NULL CHECK (selected_by IN ('human','host')),
|
|
200
|
+
principal TEXT NOT NULL DEFAULT 'owner',
|
|
201
|
+
selected_at TEXT NOT NULL,
|
|
202
|
+
updated_at TEXT NOT NULL
|
|
203
|
+
) STRICT`,
|
|
204
|
+
`CREATE INDEX IF NOT EXISTS pa_selection_project ON pa_selection(project_id)`,
|
|
205
|
+
]),
|
|
206
|
+
});
|
package/lib/registry.mjs
ADDED
|
@@ -0,0 +1,406 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Registro Project-Aware (PA1): un `registry.sqlite3` por perfil con proyectos, bibliotecas,
|
|
3
|
+
* raíces autorizadas y auditoría propia del registro.
|
|
4
|
+
*
|
|
5
|
+
* Reglas que este módulo mantiene:
|
|
6
|
+
* - La integridad se comprueba al abrir: `application_id`, versión, tablas esperadas y cadena de
|
|
7
|
+
* auditoría. Un registro incoherente no se usa «a medias»: se cierra con `registry-corrupt`.
|
|
8
|
+
* - `roots.path_key` es único global; el esquema impone además que la raíz pertenezca a un proyecto
|
|
9
|
+
* o biblioteca existente mediante disparadores.
|
|
10
|
+
* - Crear un proyecto/biblioteca/raíz es una operación **humana**: `added_by` sólo admite
|
|
11
|
+
* `human`/`host`, y la función no acepta `model`.
|
|
12
|
+
*/
|
|
13
|
+
|
|
14
|
+
import { createHash, randomBytes } from 'node:crypto';
|
|
15
|
+
import { existsSync, mkdirSync } from 'node:fs';
|
|
16
|
+
import { dirname, isAbsolute } from 'node:path';
|
|
17
|
+
import { DatabaseSync } from 'node:sqlite';
|
|
18
|
+
|
|
19
|
+
import { RagError } from './errors.mjs';
|
|
20
|
+
import { canonicalJson } from './audit.mjs';
|
|
21
|
+
import { withTransaction } from './db.mjs';
|
|
22
|
+
import { REGISTRY_APPLICATION_ID, REGISTRY_DDL, REGISTRY_MIGRATIONS, REGISTRY_VERSION } from './registry-schema.mjs';
|
|
23
|
+
import { registryPath } from './profile.mjs';
|
|
24
|
+
import {
|
|
25
|
+
assertRootStructure,
|
|
26
|
+
canonicalKey,
|
|
27
|
+
classifyRootRegistration,
|
|
28
|
+
findRootConflicts,
|
|
29
|
+
inspectRoot,
|
|
30
|
+
} from './roots-structure.mjs';
|
|
31
|
+
|
|
32
|
+
const REGISTRY_TABLES = Object.freeze([
|
|
33
|
+
'audit_registry',
|
|
34
|
+
'grants',
|
|
35
|
+
'libraries',
|
|
36
|
+
'meta',
|
|
37
|
+
'operation_steps',
|
|
38
|
+
'operations',
|
|
39
|
+
'pa_selection',
|
|
40
|
+
'projects',
|
|
41
|
+
'roots',
|
|
42
|
+
'session_scope',
|
|
43
|
+
'sync_state',
|
|
44
|
+
]);
|
|
45
|
+
|
|
46
|
+
const CROCKFORD = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
|
|
47
|
+
let lastTime = 0;
|
|
48
|
+
let sequence = 0;
|
|
49
|
+
|
|
50
|
+
/** Identificador con forma ULID (26 caracteres Crockford en mayúsculas). */
|
|
51
|
+
export function newId(prefix, now = Date.now()) {
|
|
52
|
+
let time = Math.max(now, lastTime);
|
|
53
|
+
if (time === lastTime) {
|
|
54
|
+
sequence = (sequence + 1) % 0x1000;
|
|
55
|
+
if (sequence === 0) time += 1;
|
|
56
|
+
} else {
|
|
57
|
+
sequence = 0;
|
|
58
|
+
}
|
|
59
|
+
lastTime = time;
|
|
60
|
+
const timePart = Array.from({ length: 10 }, (_, index) => CROCKFORD[Math.floor(time / 32 ** (9 - index)) % 32]).join('');
|
|
61
|
+
const random = randomBytes(16);
|
|
62
|
+
let randomPart = '';
|
|
63
|
+
for (let index = 0; index < 16; index += 1) randomPart += CROCKFORD[random[index] % 32];
|
|
64
|
+
return `${prefix}${timePart}${randomPart}`;
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
/**
|
|
68
|
+
* Clave de ruta canónica para comparar raíces sin depender de mayúsculas, separadores ni enlaces
|
|
69
|
+
* (Windows). Desde PA4 canonicaliza con `realpath` cuando la ruta existe: dos rutas que apuntan a
|
|
70
|
+
* la misma carpeta física producen la misma clave.
|
|
71
|
+
*/
|
|
72
|
+
export function pathKeyFor(path) {
|
|
73
|
+
return canonicalKey(path);
|
|
74
|
+
}
|
|
75
|
+
|
|
76
|
+
export function registryTables(db) {
|
|
77
|
+
return db.prepare(`SELECT name FROM sqlite_master WHERE type='table' ORDER BY name`).all().map((row) => row.name);
|
|
78
|
+
}
|
|
79
|
+
|
|
80
|
+
/**
|
|
81
|
+
* Abre el registro del perfil. Con `create` inicializa un registro vacío; sin él, un registro
|
|
82
|
+
* ausente es un error explícito, nunca un registro vacío implícito.
|
|
83
|
+
*/
|
|
84
|
+
export function openRegistry({ root, create = false, now = Date.now() } = {}) {
|
|
85
|
+
if (typeof root !== 'string' || !isAbsolute(root)) {
|
|
86
|
+
throw new RagError('invalid-config', 'la raíz del perfil debe ser una ruta absoluta');
|
|
87
|
+
}
|
|
88
|
+
const path = registryPath(root);
|
|
89
|
+
const exists = existsSync(path);
|
|
90
|
+
if (!exists && !create) {
|
|
91
|
+
throw new RagError('store-not-initialized', 'el registro del perfil no existe', { details: { root } });
|
|
92
|
+
}
|
|
93
|
+
if (create) mkdirSync(dirname(path), { recursive: true });
|
|
94
|
+
|
|
95
|
+
const db = new DatabaseSync(path);
|
|
96
|
+
try {
|
|
97
|
+
db.exec('PRAGMA foreign_keys = ON');
|
|
98
|
+
db.exec('PRAGMA busy_timeout = 5000');
|
|
99
|
+
db.exec('PRAGMA journal_mode = WAL');
|
|
100
|
+
db.exec('PRAGMA synchronous = FULL');
|
|
101
|
+
|
|
102
|
+
const fresh = registryTables(db).length === 0;
|
|
103
|
+
if (fresh) {
|
|
104
|
+
if (!create) throw new RagError('store-not-initialized', 'el registro del perfil está vacío');
|
|
105
|
+
initializeRegistry(db, { root, now });
|
|
106
|
+
} else {
|
|
107
|
+
// Un registro de una versión anterior se migra de forma ADITIVA antes de validarlo: sólo se
|
|
108
|
+
// crean estructuras nuevas (v1 → v2 añade `pa_selection`), ninguna fila existente se toca.
|
|
109
|
+
migrateRegistry(db, { root });
|
|
110
|
+
assertRegistry(db, { root });
|
|
111
|
+
}
|
|
112
|
+
return { db, path, root };
|
|
113
|
+
} catch (error) {
|
|
114
|
+
db.close();
|
|
115
|
+
throw error;
|
|
116
|
+
}
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
function initializeRegistry(db, { root, now }) {
|
|
120
|
+
db.exec('BEGIN IMMEDIATE');
|
|
121
|
+
try {
|
|
122
|
+
for (const statement of REGISTRY_DDL) db.exec(statement);
|
|
123
|
+
db.exec(`PRAGMA application_id = ${REGISTRY_APPLICATION_ID}`);
|
|
124
|
+
db.exec(`PRAGMA user_version = ${REGISTRY_VERSION}`);
|
|
125
|
+
const meta = db.prepare('INSERT INTO meta (key, value) VALUES (?, ?)');
|
|
126
|
+
meta.run('registry_version', String(REGISTRY_VERSION));
|
|
127
|
+
meta.run('created_at', String(now));
|
|
128
|
+
meta.run('profile_root', root);
|
|
129
|
+
meta.run('audit_head_seq', '0');
|
|
130
|
+
meta.run('audit_head_hash', '');
|
|
131
|
+
db.exec('COMMIT');
|
|
132
|
+
} catch (error) {
|
|
133
|
+
db.exec('ROLLBACK');
|
|
134
|
+
throw new RagError('internal', `no se pudo crear el registro: ${error.message}`, { cause: error });
|
|
135
|
+
}
|
|
136
|
+
}
|
|
137
|
+
|
|
138
|
+
/**
|
|
139
|
+
* Lleva el registro a `REGISTRY_VERSION` con migraciones aditivas, o no hace nada si ya está al día.
|
|
140
|
+
*
|
|
141
|
+
* Se ejecuta dentro de `BEGIN IMMEDIATE` y vuelve a leer la versión dentro de la transacción: dos
|
|
142
|
+
* procesos del mismo perfil (host y CLI) pueden abrir a la vez, y sólo uno migra; el otro encuentra
|
|
143
|
+
* el registro ya migrado y sigue. Una versión superior a la soportada no se toca: la rechaza
|
|
144
|
+
* `assertRegistry` con `store-version-unsupported`.
|
|
145
|
+
*/
|
|
146
|
+
function migrateRegistry(db, { root }) {
|
|
147
|
+
const from = Number(db.prepare('PRAGMA user_version').get().user_version);
|
|
148
|
+
if (!Number.isInteger(from) || from < 1 || from >= REGISTRY_VERSION) return;
|
|
149
|
+
db.exec('BEGIN IMMEDIATE');
|
|
150
|
+
try {
|
|
151
|
+
const current = Number(db.prepare('PRAGMA user_version').get().user_version);
|
|
152
|
+
if (current >= REGISTRY_VERSION) {
|
|
153
|
+
db.exec('COMMIT');
|
|
154
|
+
return;
|
|
155
|
+
}
|
|
156
|
+
for (let target = current + 1; target <= REGISTRY_VERSION; target += 1) {
|
|
157
|
+
for (const statement of REGISTRY_MIGRATIONS[target] ?? []) db.exec(statement);
|
|
158
|
+
}
|
|
159
|
+
db.exec(`PRAGMA user_version = ${REGISTRY_VERSION}`);
|
|
160
|
+
db.prepare(`INSERT INTO meta (key, value) VALUES ('registry_version', ?)
|
|
161
|
+
ON CONFLICT(key) DO UPDATE SET value = excluded.value`).run(String(REGISTRY_VERSION));
|
|
162
|
+
db.exec('COMMIT');
|
|
163
|
+
} catch (error) {
|
|
164
|
+
try { db.exec('ROLLBACK'); } catch { /* la transacción ya no estaba abierta */ }
|
|
165
|
+
throw new RagError('registry-corrupt', 'no se pudo migrar el registro del perfil', {
|
|
166
|
+
details: { root, from, to: REGISTRY_VERSION },
|
|
167
|
+
cause: error,
|
|
168
|
+
});
|
|
169
|
+
}
|
|
170
|
+
}
|
|
171
|
+
|
|
172
|
+
function assertRegistry(db, { root }) {
|
|
173
|
+
const appId = Number(db.prepare('PRAGMA application_id').get().application_id);
|
|
174
|
+
if (appId !== REGISTRY_APPLICATION_ID) {
|
|
175
|
+
throw new RagError('registry-corrupt', 'el fichero de registro no es de LifeCode RAG', { details: { root } });
|
|
176
|
+
}
|
|
177
|
+
const version = Number(db.prepare('PRAGMA user_version').get().user_version);
|
|
178
|
+
if (!Number.isInteger(version) || version < 1) {
|
|
179
|
+
throw new RagError('registry-corrupt', 'versión de registro inválida', { details: { version } });
|
|
180
|
+
}
|
|
181
|
+
if (version > REGISTRY_VERSION) {
|
|
182
|
+
throw new RagError('store-version-unsupported', 'el registro fue escrito por una versión más nueva', {
|
|
183
|
+
details: { found: version, supported: REGISTRY_VERSION },
|
|
184
|
+
});
|
|
185
|
+
}
|
|
186
|
+
const tables = new Set(registryTables(db));
|
|
187
|
+
const missing = REGISTRY_TABLES.filter((name) => !tables.has(name));
|
|
188
|
+
if (missing.length > 0) {
|
|
189
|
+
throw new RagError('registry-corrupt', 'al registro le faltan tablas', { details: { missing } });
|
|
190
|
+
}
|
|
191
|
+
const check = db.prepare('PRAGMA quick_check').all();
|
|
192
|
+
if (check.length !== 1 || check[0].quick_check !== 'ok') {
|
|
193
|
+
throw new RagError('registry-corrupt', 'quick_check del registro falló', { details: { check } });
|
|
194
|
+
}
|
|
195
|
+
const chain = verifyRegistryAudit(db);
|
|
196
|
+
if (!chain.ok) {
|
|
197
|
+
throw new RagError('registry-corrupt', 'la cadena de auditoría del registro no verifica', { details: chain });
|
|
198
|
+
}
|
|
199
|
+
}
|
|
200
|
+
|
|
201
|
+
export function closeRegistry(db) {
|
|
202
|
+
try {
|
|
203
|
+
db.close();
|
|
204
|
+
} catch {
|
|
205
|
+
// cerrar dos veces no es un fallo
|
|
206
|
+
}
|
|
207
|
+
}
|
|
208
|
+
|
|
209
|
+
function requireName(name) {
|
|
210
|
+
if (typeof name !== 'string' || name.trim() === '' || name.trim().length > 120) {
|
|
211
|
+
throw new RagError('invalid-argument', 'el nombre debe tener entre 1 y 120 caracteres');
|
|
212
|
+
}
|
|
213
|
+
return name.trim();
|
|
214
|
+
}
|
|
215
|
+
|
|
216
|
+
export function getMeta(db, key) {
|
|
217
|
+
const row = db.prepare('SELECT value FROM meta WHERE key = ?').get(key);
|
|
218
|
+
return row ? row.value : null;
|
|
219
|
+
}
|
|
220
|
+
|
|
221
|
+
export function setMeta(db, key, value) {
|
|
222
|
+
db.prepare(`INSERT INTO meta (key, value) VALUES (?, ?)
|
|
223
|
+
ON CONFLICT(key) DO UPDATE SET value = excluded.value`).run(key, String(value));
|
|
224
|
+
return value;
|
|
225
|
+
}
|
|
226
|
+
|
|
227
|
+
export function createProject(db, { name, now = Date.now() } = {}) {
|
|
228
|
+
const id = newId('prj_', now);
|
|
229
|
+
db.prepare(`INSERT INTO projects (id, name, status, created_at, updated_at) VALUES (?, ?, 'active', ?, ?)`)
|
|
230
|
+
.run(id, requireName(name), now, now);
|
|
231
|
+
return { id, name: name.trim(), createdAt: now };
|
|
232
|
+
}
|
|
233
|
+
|
|
234
|
+
export function createLibrary(db, { name, now = Date.now() } = {}) {
|
|
235
|
+
const id = newId('lib_', now);
|
|
236
|
+
db.prepare(`INSERT INTO libraries (id, name, status, created_at, updated_at) VALUES (?, ?, 'active', ?, ?)`)
|
|
237
|
+
.run(id, requireName(name), now, now);
|
|
238
|
+
return { id, name: name.trim(), createdAt: now };
|
|
239
|
+
}
|
|
240
|
+
|
|
241
|
+
/**
|
|
242
|
+
* Añade una raíz autorizada. La ruta debe ser absoluta y existir; la pertenencia al proyecto o
|
|
243
|
+
* biblioteca la valida el disparador del esquema.
|
|
244
|
+
*/
|
|
245
|
+
/**
|
|
246
|
+
* Añade una raíz autorizada. Desde PA4 la estructura se valida **antes** de escribir: la ruta debe
|
|
247
|
+
* existir, ser un directorio real (no enlace/junction/reparse) y no solaparse con ninguna raíz ya
|
|
248
|
+
* registrada, ni duplicarla. La pertenencia al proyecto o biblioteca la valida el disparador.
|
|
249
|
+
*/
|
|
250
|
+
export function addRoot(db, {
|
|
251
|
+
scopeKind, scopeId, path, addedBy = 'human', now = Date.now(), allowNested = false,
|
|
252
|
+
} = {}) {
|
|
253
|
+
if (!['prj', 'lib'].includes(scopeKind)) throw new RagError('invalid-argument', 'scopeKind inválido');
|
|
254
|
+
if (typeof scopeId !== 'string' || !scopeId.startsWith(scopeKind === 'prj' ? 'prj_' : 'lib_')) {
|
|
255
|
+
throw new RagError('invalid-argument', 'scopeId no corresponde al tipo de ámbito');
|
|
256
|
+
}
|
|
257
|
+
if (!['human', 'host'].includes(addedBy)) {
|
|
258
|
+
throw new RagError('invalid-argument', 'sólo una persona o el host pueden autorizar raíces');
|
|
259
|
+
}
|
|
260
|
+
if (typeof path !== 'string' || path.trim() === '' || !isAbsolute(path)) {
|
|
261
|
+
throw new RagError('invalid-argument', 'la raíz debe ser una ruta absoluta');
|
|
262
|
+
}
|
|
263
|
+
const info = assertRootStructure(inspectRoot(path));
|
|
264
|
+
const existing = listRoots(db);
|
|
265
|
+
const verdict = classifyRootRegistration({ key: info.key, path: info.canonical }, existing, { allowNested });
|
|
266
|
+
if (!verdict.ok) {
|
|
267
|
+
throw new RagError(verdict.code, verdict.message, {
|
|
268
|
+
details: {
|
|
269
|
+
path: info.canonical,
|
|
270
|
+
relation: verdict.conflict.relation,
|
|
271
|
+
conflictsWith: {
|
|
272
|
+
scopeKind: verdict.conflict.root.scope_kind,
|
|
273
|
+
scopeId: verdict.conflict.root.scope_id,
|
|
274
|
+
path: verdict.conflict.root.path,
|
|
275
|
+
},
|
|
276
|
+
},
|
|
277
|
+
});
|
|
278
|
+
}
|
|
279
|
+
|
|
280
|
+
const id = newId('rt_', now);
|
|
281
|
+
try {
|
|
282
|
+
db.prepare(`INSERT INTO roots (id, scope_kind, scope_id, path, path_key, state, added_at, added_by)
|
|
283
|
+
VALUES (?, ?, ?, ?, ?, 'authorized', ?, ?)`)
|
|
284
|
+
.run(id, scopeKind, scopeId, info.canonical, info.key, now, addedBy);
|
|
285
|
+
} catch (error) {
|
|
286
|
+
if (String(error.message).includes('UNIQUE') || String(error.message).includes('unique')) {
|
|
287
|
+
throw new RagError('invalid-argument', 'esa ruta ya está registrada en este perfil', {
|
|
288
|
+
details: { path: info.canonical },
|
|
289
|
+
cause: error,
|
|
290
|
+
});
|
|
291
|
+
}
|
|
292
|
+
throw error;
|
|
293
|
+
}
|
|
294
|
+
return { id, scopeKind, scopeId, path: info.canonical, pathKey: info.key };
|
|
295
|
+
}
|
|
296
|
+
|
|
297
|
+
export function getProject(db, id) {
|
|
298
|
+
return db.prepare('SELECT * FROM projects WHERE id = ?').get(id) ?? null;
|
|
299
|
+
}
|
|
300
|
+
|
|
301
|
+
export function listRoots(db, { scopeKind, scopeId } = {}) {
|
|
302
|
+
if (scopeKind && scopeId) {
|
|
303
|
+
return db.prepare('SELECT * FROM roots WHERE scope_kind = ? AND scope_id = ? ORDER BY path').all(scopeKind, scopeId);
|
|
304
|
+
}
|
|
305
|
+
return db.prepare('SELECT * FROM roots ORDER BY path').all();
|
|
306
|
+
}
|
|
307
|
+
|
|
308
|
+
function registryAuditPayload(entry) {
|
|
309
|
+
return {
|
|
310
|
+
at: Number(entry.at),
|
|
311
|
+
actor: entry.actor,
|
|
312
|
+
sessionId: entry.sessionId ?? null,
|
|
313
|
+
action: entry.action,
|
|
314
|
+
target: entry.target,
|
|
315
|
+
outcome: entry.outcome,
|
|
316
|
+
detail: normalizeDetail(entry.detail),
|
|
317
|
+
};
|
|
318
|
+
}
|
|
319
|
+
|
|
320
|
+
/**
|
|
321
|
+
* El detalle se guarda siempre como texto JSON: así el hash es estable y no depende de que cada
|
|
322
|
+
* llamador se acuerde de serializar (un objeto pasado crudo rompía el enlace de SQLite).
|
|
323
|
+
*/
|
|
324
|
+
function normalizeDetail(detail) {
|
|
325
|
+
if (detail === undefined || detail === null) return null;
|
|
326
|
+
return typeof detail === 'string' ? detail : JSON.stringify(detail);
|
|
327
|
+
}
|
|
328
|
+
|
|
329
|
+
export function registryAuditHash(prevHash, entry) {
|
|
330
|
+
return createHash('sha256').update(`${prevHash}\n${canonicalJson(registryAuditPayload(entry))}`, 'utf8').digest('hex');
|
|
331
|
+
}
|
|
332
|
+
|
|
333
|
+
/**
|
|
334
|
+
* Añade una entrada a la cadena de auditoría del registro.
|
|
335
|
+
*
|
|
336
|
+
* La lectura de la cabeza, el cálculo del hash, el `INSERT` y la actualización de `meta` van en la
|
|
337
|
+
* MISMA transacción `IMMEDIATE`: dos conexiones del perfil (host y CLI, por ejemplo) se serializan y
|
|
338
|
+
* la cadena no puede quedar con un `prev_hash` que no cuadre —lo que dejaría el perfil entero
|
|
339
|
+
* inservible, porque `assertRegistry` verifica la cadena al abrir—. Si el llamador ya está en una
|
|
340
|
+
* transacción se reutiliza esa: abrir otra dentro fallaría.
|
|
341
|
+
*/
|
|
342
|
+
export function appendRegistryAudit(db, entry) {
|
|
343
|
+
const append = () => {
|
|
344
|
+
const head = Number(db.prepare(`SELECT value FROM meta WHERE key='audit_head_seq'`).get()?.value ?? '0');
|
|
345
|
+
let prevHash = '0'.repeat(64);
|
|
346
|
+
if (head > 0) {
|
|
347
|
+
const row = db.prepare('SELECT hash FROM audit_registry WHERE seq = ?').get(head);
|
|
348
|
+
if (!row) throw new RagError('registry-corrupt', `falta la entrada de auditoría del registro ${head}`);
|
|
349
|
+
prevHash = row.hash;
|
|
350
|
+
}
|
|
351
|
+
const payload = registryAuditPayload(entry);
|
|
352
|
+
const hash = registryAuditHash(prevHash, payload);
|
|
353
|
+
const info = db.prepare(`INSERT INTO audit_registry (at, actor, session_id, action, target, outcome, detail, prev_hash, hash)
|
|
354
|
+
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(
|
|
355
|
+
payload.at, payload.actor, payload.sessionId, payload.action, payload.target,
|
|
356
|
+
payload.outcome, payload.detail, prevHash, hash,
|
|
357
|
+
);
|
|
358
|
+
const seq = Number(info.lastInsertRowid);
|
|
359
|
+
db.prepare(`UPDATE meta SET value=? WHERE key='audit_head_seq'`).run(String(seq));
|
|
360
|
+
db.prepare(`UPDATE meta SET value=? WHERE key='audit_head_hash'`).run(hash);
|
|
361
|
+
return { seq, hash };
|
|
362
|
+
};
|
|
363
|
+
return db.isTransaction ? append() : withTransaction(db, append, { immediate: true });
|
|
364
|
+
}
|
|
365
|
+
|
|
366
|
+
export function verifyRegistryAudit(db) {
|
|
367
|
+
const rows = db.prepare(`SELECT seq, at, actor, session_id, action, target, outcome, detail, prev_hash, hash
|
|
368
|
+
FROM audit_registry ORDER BY seq ASC`).all();
|
|
369
|
+
let prevHash = '0'.repeat(64);
|
|
370
|
+
for (const row of rows) {
|
|
371
|
+
if (row.prev_hash !== prevHash) return { ok: false, brokenAt: row.seq, reason: 'prev-hash' };
|
|
372
|
+
const expected = registryAuditHash(prevHash, {
|
|
373
|
+
at: row.at,
|
|
374
|
+
actor: row.actor,
|
|
375
|
+
sessionId: row.session_id,
|
|
376
|
+
action: row.action,
|
|
377
|
+
target: row.target,
|
|
378
|
+
outcome: row.outcome,
|
|
379
|
+
detail: row.detail,
|
|
380
|
+
});
|
|
381
|
+
if (expected !== row.hash) return { ok: false, brokenAt: row.seq, reason: 'hash' };
|
|
382
|
+
prevHash = row.hash;
|
|
383
|
+
}
|
|
384
|
+
const head = Number(db.prepare(`SELECT value FROM meta WHERE key='audit_head_seq'`).get()?.value ?? '0');
|
|
385
|
+
if (head !== rows.length) return { ok: false, brokenAt: head, reason: 'head' };
|
|
386
|
+
return { ok: true, count: rows.length };
|
|
387
|
+
}
|
|
388
|
+
|
|
389
|
+
/** Comprobación de integridad completa (usada por el informe y las pruebas). */
|
|
390
|
+
export function registryIntegrity(db) {
|
|
391
|
+
const foreign = db.prepare('PRAGMA foreign_key_check').all();
|
|
392
|
+
const roots = listRoots(db);
|
|
393
|
+
const rootConflicts = findRootConflicts(roots);
|
|
394
|
+
return {
|
|
395
|
+
quickCheck: db.prepare('PRAGMA quick_check').all().map((row) => row.quick_check).join(','),
|
|
396
|
+
foreignKeys: foreign.length,
|
|
397
|
+
tables: registryTables(db).length,
|
|
398
|
+
roots: roots.length,
|
|
399
|
+
rootConflicts: rootConflicts.map(({ left, right, relation }) => ({
|
|
400
|
+
relation,
|
|
401
|
+
left: { scopeKind: left.scope_kind, scopeId: left.scope_id, path: left.path },
|
|
402
|
+
right: { scopeKind: right.scope_kind, scopeId: right.scope_id, path: right.path },
|
|
403
|
+
})),
|
|
404
|
+
audit: verifyRegistryAudit(db),
|
|
405
|
+
};
|
|
406
|
+
}
|