@mmnto/totem 1.21.0 → 1.22.0

package/dist/chunkers/chunker-registry.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Runtime chunker registry (ADR-097 § 5 Q3, mmnto-ai/totem#1769).
+ *
+ * Replaces the closed `CHUNKER_MAP` keyed by the closed `ChunkStrategy` Zod
+ * enum. The registry is a string-keyed Map populated by:
+ *
+ * 1. Built-in chunkers self-registering at module load (this file's bottom).
+ * 2. Pack registration callbacks invoked by `loadInstalledPacks()` during
+ *    boot (mmnto-ai/totem#1768) — they register via the
+ *    `PackRegistrationAPI.registerChunkStrategy()` surface, which calls
+ *    through to `register()` in this module.
+ *
+ * After boot completes, the engine seals (`pack-discovery.ts` flips
+ * `engineSealed = true`) and any further `register()` call throws.
+ *
+ * The registry has no concept of which built-in vs pack-registered an
+ * entry is — that distinction is enforced at registration time (see
+ * `register()` and `BUILTIN_CHUNKER_NAMES`).
+ */
+import type { Chunker } from './chunker.js';
+/**
+ * Register a chunker under a strategy name. Called by built-ins at module
+ * load and by Pack registration callbacks during boot. Throws when:
+ *
+ * - `engineSealed` (per `pack-discovery.ts`) is true.
+ * - The strategy name is already registered (built-ins are immutable;
+ *   pack-vs-pack collisions are also rejected).
+ *
+ * Boot vs pack distinction: built-ins call `register()` directly at
+ * module-load time (sealed === false, name not yet in registry → succeeds).
+ * Packs call via `PackRegistrationAPI.registerChunkStrategy` which routes
+ * to this same function. The seal check + name-collision check covers both
+ * in one place.
+ */
+export declare function register(name: string, chunkerCtor: new () => Chunker): void;
+/**
+ * Look up a chunker class by strategy name. Returns undefined when the
+ * name isn't registered — callers decide whether absence is a hard error
+ * (Zod validation), a fail-loud at runtime (createChunker), or a soft
+ * miss.
+ */
+export declare function lookup(name: string): (new () => Chunker) | undefined;
+/**
+ * Snapshot of currently-registered strategy names. Used for:
+ *
+ * - `ChunkStrategySchema` validation error messages (suggesting the valid set).
+ * - `totem describe` output enumerating effective strategies.
+ *
+ * Returns a sorted array for deterministic output.
+ */
+export declare function registeredNames(): readonly string[];
+/**
+ * True iff the strategy name is one of the built-ins (vs pack-registered).
+ * Used by tooling that needs to distinguish core-shipped strategies from
+ * pack-contributed ones.
+ */
+export declare function isBuiltin(name: string): boolean;
+/**
+ * Mark the registry as sealed. After this, `register()` calls throw.
+ * Called by `pack-discovery.ts` `loadInstalledPacks()` after every pack
+ * callback returns.
+ *
+ * The seal applies process-wide. Tests that need to register additional
+ * fixture chunkers between cases use `__unsealForTests()`.
+ */
+export declare function seal(): void;
+/** True iff the registry has been sealed. */
+export declare function isSealed(): boolean;
+/**
+ * Test-only: reset the registry and re-register built-ins. Lets per-test
+ * fixtures register without leaking state across tests. NEVER call from
+ * production code.
+ */
+export declare function __resetForTests(): void;
+/** Test-only: clear the seal so subsequent registrations succeed. */
+export declare function __unsealForTests(): void;
+//# sourceMappingURL=chunker-registry.d.ts.map

package/dist/chunkers/chunker-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunker-registry.d.ts","sourceRoot":"","sources":["../../src/chunkers/chunker-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAyB5C;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,UAAU,OAAO,GAAG,IAAI,CAa3E;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,UAAU,OAAO,CAAC,GAAG,SAAS,CAEpE;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,IAAI,SAAS,MAAM,EAAE,CAEnD;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE/C;AAED;;;;;;;GAOG;AACH,wBAAgB,IAAI,IAAI,IAAI,CAE3B;AAED,6CAA6C;AAC7C,wBAAgB,QAAQ,IAAI,OAAO,CAElC;AAID;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAKtC;AAED,qEAAqE;AACrE,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC"}

package/dist/chunkers/chunker-registry.js

@@ -0,0 +1,134 @@
+/**
+ * Runtime chunker registry (ADR-097 § 5 Q3, mmnto-ai/totem#1769).
+ *
+ * Replaces the closed `CHUNKER_MAP` keyed by the closed `ChunkStrategy` Zod
+ * enum. The registry is a string-keyed Map populated by:
+ *
+ * 1. Built-in chunkers self-registering at module load (this file's bottom).
+ * 2. Pack registration callbacks invoked by `loadInstalledPacks()` during
+ *    boot (mmnto-ai/totem#1768) — they register via the
+ *    `PackRegistrationAPI.registerChunkStrategy()` surface, which calls
+ *    through to `register()` in this module.
+ *
+ * After boot completes, the engine seals (`pack-discovery.ts` flips
+ * `engineSealed = true`) and any further `register()` call throws.
+ *
+ * The registry has no concept of which built-in vs pack-registered an
+ * entry is — that distinction is enforced at registration time (see
+ * `register()` and `BUILTIN_CHUNKER_NAMES`).
+ */
+import { MarkdownChunker } from './markdown-chunker.js';
+import { SchemaFileChunker } from './schema-file-chunker.js';
+import { SessionLogChunker } from './session-log-chunker.js';
+import { TestFileChunker } from './test-file-chunker.js';
+import { TypeScriptChunker } from './typescript-chunker.js';
+// ─── Internal state ─────────────────────────────────
+const CHUNKER_REGISTRY = new Map();
+/**
+ * Built-in chunker names, immutable. A pack attempting to re-register one
+ * of these names is rejected at the boundary in `register()`. The set is
+ * populated alongside the initial registrations below; we read it at
+ * registration time, so adding a new built-in only requires editing the
+ * `register()` calls at the bottom of this file.
+ */
+const BUILTIN_CHUNKER_NAMES = new Set();
+/** Cleared by `__resetForTests` / `unsealForTests` — see pack-discovery.ts. */
+let sealed = false;
+// ─── Public API ─────────────────────────────────────
+/**
+ * Register a chunker under a strategy name. Called by built-ins at module
+ * load and by Pack registration callbacks during boot. Throws when:
+ *
+ * - `engineSealed` (per `pack-discovery.ts`) is true.
+ * - The strategy name is already registered (built-ins are immutable;
+ *   pack-vs-pack collisions are also rejected).
+ *
+ * Boot vs pack distinction: built-ins call `register()` directly at
+ * module-load time (sealed === false, name not yet in registry → succeeds).
+ * Packs call via `PackRegistrationAPI.registerChunkStrategy` which routes
+ * to this same function. The seal check + name-collision check covers both
+ * in one place.
+ */
+export function register(name, chunkerCtor) {
+    if (sealed) {
+        throw new Error(`Chunker registration after engine seal: tried to register '${name}' but engine has already started serving requests. Pack registration must complete during boot — see ADR-097 § 5 Q5.`);
+    }
+    if (CHUNKER_REGISTRY.has(name)) {
+        const existingIsBuiltin = BUILTIN_CHUNKER_NAMES.has(name);
+        throw new Error(`Chunker '${name}' is already registered${existingIsBuiltin ? ' as a built-in (built-in entries are immutable)' : ' (pack-vs-pack collision — one of the packs must rename)'}.`);
+    }
+    CHUNKER_REGISTRY.set(name, chunkerCtor);
+}
+/**
+ * Look up a chunker class by strategy name. Returns undefined when the
+ * name isn't registered — callers decide whether absence is a hard error
+ * (Zod validation), a fail-loud at runtime (createChunker), or a soft
+ * miss.
+ */
+export function lookup(name) {
+    return CHUNKER_REGISTRY.get(name);
+}
+/**
+ * Snapshot of currently-registered strategy names. Used for:
+ *
+ * - `ChunkStrategySchema` validation error messages (suggesting the valid set).
+ * - `totem describe` output enumerating effective strategies.
+ *
+ * Returns a sorted array for deterministic output.
+ */
+export function registeredNames() {
+    return [...CHUNKER_REGISTRY.keys()].sort();
+}
+/**
+ * True iff the strategy name is one of the built-ins (vs pack-registered).
+ * Used by tooling that needs to distinguish core-shipped strategies from
+ * pack-contributed ones.
+ */
+export function isBuiltin(name) {
+    return BUILTIN_CHUNKER_NAMES.has(name);
+}
+/**
+ * Mark the registry as sealed. After this, `register()` calls throw.
+ * Called by `pack-discovery.ts` `loadInstalledPacks()` after every pack
+ * callback returns.
+ *
+ * The seal applies process-wide. Tests that need to register additional
+ * fixture chunkers between cases use `__unsealForTests()`.
+ */
+export function seal() {
+    sealed = true;
+}
+/** True iff the registry has been sealed. */
+export function isSealed() {
+    return sealed;
+}
+// ─── Test-only helpers ──────────────────────────────
+/**
+ * Test-only: reset the registry and re-register built-ins. Lets per-test
+ * fixtures register without leaking state across tests. NEVER call from
+ * production code.
+ */
+export function __resetForTests() {
+    CHUNKER_REGISTRY.clear();
+    BUILTIN_CHUNKER_NAMES.clear();
+    sealed = false;
+    registerBuiltins();
+}
+/** Test-only: clear the seal so subsequent registrations succeed. */
+export function __unsealForTests() {
+    sealed = false;
+}
+// ─── Built-in registration (runs at module load) ────
+function registerBuiltin(name, ctor) {
+    BUILTIN_CHUNKER_NAMES.add(name);
+    register(name, ctor);
+}
+function registerBuiltins() {
+    registerBuiltin('session-log', SessionLogChunker);
+    registerBuiltin('markdown-heading', MarkdownChunker);
+    registerBuiltin('typescript-ast', TypeScriptChunker);
+    registerBuiltin('schema-file', SchemaFileChunker);
+    registerBuiltin('test-file', TestFileChunker);
+}
+registerBuiltins();
+//# sourceMappingURL=chunker-registry.js.map

package/dist/chunkers/chunker-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunker-registry.js","sourceRoot":"","sources":["../../src/chunkers/chunker-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAE5D,uDAAuD;AAEvD,MAAM,gBAAgB,GAAG,IAAI,GAAG,EAA6B,CAAC;AAE9D;;;;;;GAMG;AACH,MAAM,qBAAqB,GAAG,IAAI,GAAG,EAAU,CAAC;AAEhD,+EAA+E;AAC/E,IAAI,MAAM,GAAG,KAAK,CAAC;AAEnB,uDAAuD;AAEvD;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,QAAQ,CAAC,IAAY,EAAE,WAA8B;IACnE,IAAI,MAAM,EAAE,CAAC;QACX,MAAM,IAAI,KAAK,CACb,8DAA8D,IAAI,sHAAsH,CACzL,CAAC;IACJ,CAAC;IACD,IAAI,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAC/B,MAAM,iBAAiB,GAAG,qBAAqB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC1D,MAAM,IAAI,KAAK,CACb,YAAY,IAAI,0BAA0B,iBAAiB,CAAC,CAAC,CAAC,iDAAiD,CAAC,CAAC,CAAC,0DAA0D,GAAG,CAChL,CAAC;IACJ,CAAC;IACD,gBAAgB,CAAC,GAAG,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;AAC1C,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,MAAM,CAAC,IAAY;IACjC,OAAO,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AACpC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,eAAe;IAC7B,OAAO,CAAC,GAAG,gBAAgB,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;AAC7C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,SAAS,CAAC,IAAY;IACpC,OAAO,qBAAqB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AACzC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,IAAI;IAClB,MAAM,GAAG,IAAI,CAAC;AAChB,CAAC;AAED,6CAA6C;AAC7C,MAAM,UAAU,QAAQ;IACtB,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,uDAAuD;AAEvD;;;;GAIG;AACH,MAAM,UAAU,eAAe;IAC7B,gBAAgB,CAAC,KAAK,EAAE,CAAC;IACzB,qBAAqB,CAAC,KAAK,EAAE,CAAC;IAC9B,MAAM,GAAG,KAAK,CAAC;IACf,gBAAgB,EAAE,CAAC;AACrB,CAAC;AAED,qEAAqE;AACrE,MAAM,UAAU,gBAAgB;IAC9B,MAAM,GAAG,KAAK,CAAC;AACjB,CAAC;AAED,uDAAuD;AAEvD,SAAS,eAAe,CAAC,IAAY,EAAE,IAAuB;IAC5D,qBAAqB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AACvB,CAAC;AAED,SAAS,gBAAgB;IACvB,eAAe,CAAC,aAAa,EAAE,iBAAiB,CAAC,CAAC;IAClD,eAAe,CAAC,kBAAkB,EAAE,eAAe,CAAC,CAAC;IACrD,eAAe,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAAC;IACrD,eAAe,CAAC,aAAa,EAAE,iBAAiB,CAAC,CAAC;IAClD,eAAe,CAAC,WAAW,EAAE,eAAe,CAAC,CAAC;AAChD,CAAC;AAED,gBAAgB,EAAE,CAAC"}

package/dist/chunkers/chunker-registry.test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Tests for the chunker registry (mmnto-ai/totem#1769, ADR-097 § 5 Q3).
+ *
+ * Covers invariants 4-9 + 11 (chunker side) from
+ * `.totem/specs/pack-substrate-bundle.md`:
+ *
+ * - All five built-in chunkers self-register at module load.
+ * - Pack-style registration adds new entries.
+ * - Re-registration of the same name throws.
+ * - Registering a built-in name throws (immutable).
+ * - Post-seal mutation throws.
+ */
+export {};
+//# sourceMappingURL=chunker-registry.test.d.ts.map

package/dist/chunkers/chunker-registry.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunker-registry.test.d.ts","sourceRoot":"","sources":["../../src/chunkers/chunker-registry.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG"}

package/dist/chunkers/chunker-registry.test.js

@@ -0,0 +1,95 @@
+/**
+ * Tests for the chunker registry (mmnto-ai/totem#1769, ADR-097 § 5 Q3).
+ *
+ * Covers invariants 4-9 + 11 (chunker side) from
+ * `.totem/specs/pack-substrate-bundle.md`:
+ *
+ * - All five built-in chunkers self-register at module load.
+ * - Pack-style registration adds new entries.
+ * - Re-registration of the same name throws.
+ * - Registering a built-in name throws (immutable).
+ * - Post-seal mutation throws.
+ */
+import { afterEach, describe, expect, it } from 'vitest';
+import { __resetForTests, __unsealForTests, isBuiltin, isSealed, lookup, register, registeredNames, seal, } from './chunker-registry.js';
+class FakeChunker {
+    strategy = 'fake-strategy';
+    chunk(_content, _filePath, _type) {
+        return [];
+    }
+}
+class AnotherFakeChunker {
+    strategy = 'another-fake';
+    chunk(_content, _filePath, _type) {
+        return [];
+    }
+}
+afterEach(() => {
+    // Each test gets a fresh registry with built-ins re-registered. Without
+    // this, a sealed registry from a prior test would leak into subsequent
+    // ones and they'd all fail with "after seal" errors.
+    __resetForTests();
+});
+describe('chunker-registry built-ins', () => {
+    it('registers all five built-in chunkers at module load', () => {
+        expect(lookup('session-log')).toBeDefined();
+        expect(lookup('markdown-heading')).toBeDefined();
+        expect(lookup('typescript-ast')).toBeDefined();
+        expect(lookup('schema-file')).toBeDefined();
+        expect(lookup('test-file')).toBeDefined();
+    });
+    it('exposes registered names sorted alphabetically', () => {
+        expect(registeredNames()).toEqual([
+            'markdown-heading',
+            'schema-file',
+            'session-log',
+            'test-file',
+            'typescript-ast',
+        ]);
+    });
+    it('marks built-ins as built-in', () => {
+        expect(isBuiltin('markdown-heading')).toBe(true);
+        expect(isBuiltin('typescript-ast')).toBe(true);
+        expect(isBuiltin('not-a-real-strategy')).toBe(false);
+    });
+});
+describe('chunker-registry pack-style registration', () => {
+    it('accepts new strategy registration before seal', () => {
+        register('fake-strategy', FakeChunker);
+        expect(lookup('fake-strategy')).toBe(FakeChunker);
+        expect(registeredNames()).toContain('fake-strategy');
+    });
+    it('does not mark pack-registered names as built-in', () => {
+        register('fake-strategy', FakeChunker);
+        expect(isBuiltin('fake-strategy')).toBe(false);
+    });
+    it('throws when re-registering the same strategy name (pack-vs-pack collision)', () => {
+        register('fake-strategy', FakeChunker);
+        expect(() => register('fake-strategy', AnotherFakeChunker)).toThrowError(/already registered.*pack-vs-pack collision/);
+    });
+    it('throws when registering a built-in name (built-ins immutable)', () => {
+        expect(() => register('markdown-heading', FakeChunker)).toThrowError(/already registered.*as a built-in.*immutable/);
+    });
+});
+describe('chunker-registry seal contract', () => {
+    it('starts unsealed', () => {
+        expect(isSealed()).toBe(false);
+    });
+    it('seal() flips the flag', () => {
+        seal();
+        expect(isSealed()).toBe(true);
+    });
+    it('register() after seal throws with ADR-097 § 5 Q5 reference', () => {
+        seal();
+        expect(() => register('fake-strategy', FakeChunker)).toThrowError(/after engine seal.*ADR-097 § 5 Q5/);
+    });
+    it('__unsealForTests reverts the seal so subsequent tests can register', () => {
+        seal();
+        expect(isSealed()).toBe(true);
+        __unsealForTests();
+        expect(isSealed()).toBe(false);
+        register('fake-strategy', FakeChunker);
+        expect(lookup('fake-strategy')).toBe(FakeChunker);
+    });
+});
+//# sourceMappingURL=chunker-registry.test.js.map

package/dist/chunkers/chunker-registry.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunker-registry.test.js","sourceRoot":"","sources":["../../src/chunkers/chunker-registry.test.ts"],"names":[],"mappings":"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"}

package/dist/chunkers/chunker.d.ts

@@ -1,12 +1,27 @@
-import type { ChunkStrategy, ContentType } from '../config-schema.js';
+import type { ContentType } from '../config-schema.js';
 import type { Chunk } from '../types.js';
 /**
  * All chunkers implement this interface.
  * Given file content and metadata, produce an array of Chunks.
  */
 export interface Chunker {
-    readonly strategy: ChunkStrategy;
+    readonly strategy: string;
     chunk(content: string, filePath: string, type: ContentType): Chunk[];
 }
-export declare function createChunker(strategy: ChunkStrategy): Chunker;
+/**
+ * Resolve a strategy name to a fresh chunker instance via the registry.
+ *
+ * Pre-ADR-097 the strategy → constructor mapping was a closed `Record`
+ * keyed by the closed `ChunkStrategy` Zod enum (mmnto-ai/totem#1769).
+ * Now the lookup goes through `chunker-registry.ts`, which is populated
+ * by built-ins at module load and extended by Pack registration
+ * callbacks during boot.
+ *
+ * Fail-loud per Tenet 4: an unregistered strategy name names the missing
+ * pack (callers consume the registry's `registeredNames()` for context).
+ * Schema validation (`ChunkStrategySchema`) catches misconfigured strategy
+ * names at config-load time, so reaching this fail-loud at runtime is an
+ * architectural error.
+ */
+export declare function createChunker(strategy: string): Chunker;
 //# sourceMappingURL=chunker.d.ts.map

package/dist/chunkers/chunker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunker.d.ts","sourceRoot":"","sources":["../../src/chunkers/chunker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACtE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAOzC;;;GAGG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IAEjC,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,KAAK,EAAE,CAAC;CACtE;AAUD,wBAAgB,aAAa,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAG9D"}
+{"version":3,"file":"chunker.d.ts","sourceRoot":"","sources":["../../src/chunkers/chunker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGzC;;;GAGG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,KAAK,EAAE,CAAC;CACtE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAQvD"}

package/dist/chunkers/chunker.js

@@ -1,17 +1,24 @@
-import { MarkdownChunker } from './markdown-chunker.js';
-import { SchemaFileChunker } from './schema-file-chunker.js';
-import { SessionLogChunker } from './session-log-chunker.js';
-import { TestFileChunker } from './test-file-chunker.js';
-import { TypeScriptChunker } from './typescript-chunker.js';
-const CHUNKER_MAP = {
-    'session-log': SessionLogChunker,
-    'markdown-heading': MarkdownChunker,
-    'typescript-ast': TypeScriptChunker,
-    'schema-file': SchemaFileChunker,
-    'test-file': TestFileChunker,
-};
+import { lookup } from './chunker-registry.js';
+/**
+ * Resolve a strategy name to a fresh chunker instance via the registry.
+ *
+ * Pre-ADR-097 the strategy → constructor mapping was a closed `Record`
+ * keyed by the closed `ChunkStrategy` Zod enum (mmnto-ai/totem#1769).
+ * Now the lookup goes through `chunker-registry.ts`, which is populated
+ * by built-ins at module load and extended by Pack registration
+ * callbacks during boot.
+ *
+ * Fail-loud per Tenet 4: an unregistered strategy name names the missing
+ * pack (callers consume the registry's `registeredNames()` for context).
+ * Schema validation (`ChunkStrategySchema`) catches misconfigured strategy
+ * names at config-load time, so reaching this fail-loud at runtime is an
+ * architectural error.
+ */
 export function createChunker(strategy) {
-    const Ctor = CHUNKER_MAP[strategy];
+    const Ctor = lookup(strategy);
+    if (!Ctor) {
+        throw new Error(`Unknown chunk strategy: '${strategy}'. The strategy is not registered — either install the pack that provides it or correct the strategy name in totem.config.ts.`);
+    }
     return new Ctor();
 }
 //# sourceMappingURL=chunker.js.map

package/dist/chunkers/chunker.js.map

@@ -1 +1 @@
-{"version":3,"file":"chunker.js","sourceRoot":"","sources":["../../src/chunkers/chunker.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAY5D,MAAM,WAAW,GAA6C;IAC5D,aAAa,EAAE,iBAAiB;IAChC,kBAAkB,EAAE,eAAe;IACnC,gBAAgB,EAAE,iBAAiB;IACnC,aAAa,EAAE,iBAAiB;IAChC,WAAW,EAAE,eAAe;CAC7B,CAAC;AAEF,MAAM,UAAU,aAAa,CAAC,QAAuB;IACnD,MAAM,IAAI,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC;IACnC,OAAO,IAAI,IAAI,EAAE,CAAC;AACpB,CAAC"}
+{"version":3,"file":"chunker.js","sourceRoot":"","sources":["../../src/chunkers/chunker.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAY/C;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,aAAa,CAAC,QAAgB;IAC5C,MAAM,IAAI,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC9B,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,MAAM,IAAI,KAAK,CACb,4BAA4B,QAAQ,+HAA+H,CACpK,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,IAAI,EAAE,CAAC;AACpB,CAAC"}

package/dist/config-schema.d.ts

@@ -2,20 +2,48 @@ import { z } from 'zod';
 /**
  * Zod schema for totem.config.ts — lives at the root of consuming projects.
  */
-export declare const ChunkStrategySchema: z.ZodEnum<["typescript-ast", "markdown-heading", "session-log", "schema-file", "test-file"]>;
+/**
+ * Built-in chunk strategy names. Exported so the literal union derived
+ * via `typeof BUILTIN_CHUNK_STRATEGIES[number]` keeps the runtime list
+ * and the type signature in sync with a single source of truth. Pack-
+ * contributed strategies extend `ChunkStrategy` via the `(string & {})`
+ * tail and register at boot through `chunker-registry.ts`.
+ */
+export declare const BUILTIN_CHUNK_STRATEGIES: readonly ["typescript-ast", "markdown-heading", "session-log", "schema-file", "test-file"];
+/**
+ * `ChunkStrategy` schema. Per ADR-097 § 10 + mmnto-ai/totem#1769 strategy
+ * lookup goes through `chunker-registry.ts` at runtime; this schema only
+ * shape-checks the input string.
+ *
+ * **Why not refine against the registry here?** Bootstrap chicken-and-egg
+ * (Gemini review of mmnto-ai/totem#1768 PR-A): config parse runs BEFORE
+ * `loadInstalledPacks()` populates the registry with pack-contributed
+ * strategies (the manifest is read AFTER config load by every command).
+ * A strict registry-check at parse time would crash `totem sync` on the
+ * very edit that adds the pack — user adds `@totem/pack-foo` to extends
+ * AND a target with `strategy: 'foo-strat'` in the same change, sync
+ * fails to parse the config, never writes installed-packs.json, never
+ * registers the pack. Forever stuck.
+ *
+ * The actual fail-loud happens at `createChunker(strategy)` in
+ * `chunkers/chunker.ts` — runtime lookup against the post-boot registry
+ * with a structured error naming the missing strategy. That's the right
+ * boundary because by then the registry IS populated.
+ */
+export declare const ChunkStrategySchema: z.ZodString;
 export declare const ContentTypeSchema: z.ZodEnum<["code", "session_log", "spec", "lesson"]>;
 export declare const IngestTargetSchema: z.ZodObject<{
     glob: z.ZodString;
     type: z.ZodEnum<["code", "session_log", "spec", "lesson"]>;
-    strategy: z.ZodEnum<["typescript-ast", "markdown-heading", "session-log", "schema-file", "test-file"]>;
+    strategy: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     type: "code" | "session_log" | "spec" | "lesson";
     glob: string;
-    strategy: "typescript-ast" | "markdown-heading" | "session-log" | "schema-file" | "test-file";
+    strategy: string;
 }, {
     type: "code" | "session_log" | "spec" | "lesson";
     glob: string;
-    strategy: "typescript-ast" | "markdown-heading" | "session-log" | "schema-file" | "test-file";
+    strategy: string;
 }>;
 export declare const OpenAIProviderSchema: z.ZodObject<{
     provider: z.ZodLiteral<"openai">;
@@ -788,15 +816,15 @@ export declare const TotemConfigSchema: z.ZodObject<{
     targets: z.ZodArray<z.ZodObject<{
         glob: z.ZodString;
         type: z.ZodEnum<["code", "session_log", "spec", "lesson"]>;
-        strategy: z.ZodEnum<["typescript-ast", "markdown-heading", "session-log", "schema-file", "test-file"]>;
+        strategy: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         type: "code" | "session_log" | "spec" | "lesson";
         glob: string;
-        strategy: "typescript-ast" | "markdown-heading" | "session-log" | "schema-file" | "test-file";
+        strategy: string;
     }, {
         type: "code" | "session_log" | "spec" | "lesson";
         glob: string;
-        strategy: "typescript-ast" | "markdown-heading" | "session-log" | "schema-file" | "test-file";
+        strategy: string;
     }>, "many">;
     /** Embedding provider configuration (optional for Lite tier) */
     embedding: z.ZodOptional<z.ZodDiscriminatedUnion<"provider", [z.ZodObject<{
@@ -1190,6 +1218,19 @@ export declare const TotemConfigSchema: z.ZodObject<{
     botMarkers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     /** Optional: paths to other totem-managed directories whose indexes should be queried alongside this one (e.g., ['.strategy', '../docs-repo']) */
     linkedIndexes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Optional: pack package names to extend rules from (ADR-085 + ADR-097).
+     *
+     * Each entry is a pack name like `@totem/pack-rust-architecture`. The
+     * pack must also appear in the consumer's `package.json` dependencies
+     * (or devDependencies) so npm/pnpm can resolve it. Pack-merge logic
+     * (`packages/core/src/pack-merge.ts`) reads pack rules at lint time.
+     * Pack discovery (`packages/core/src/pack-discovery.ts`,
+     * mmnto-ai/totem#1768) reads this field plus the project's
+     * package.json dependencies, deduplicates, and writes the union to
+     * `.totem/installed-packs.json` for boot-time registration.
+     */
+    extends: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     /**
      * Optional: path override for the strategy repository (mmnto-ai/totem#1710).
      *
@@ -1337,7 +1378,7 @@ export declare const TotemConfigSchema: z.ZodObject<{
     targets: {
         type: "code" | "session_log" | "spec" | "lesson";
         glob: string;
-        strategy: "typescript-ast" | "markdown-heading" | "session-log" | "schema-file" | "test-file";
+        strategy: string;
     }[];
     totemDir: string;
     lanceDir: string;
@@ -1427,6 +1468,7 @@ export declare const TotemConfigSchema: z.ZodObject<{
     repositories?: string[] | undefined;
     botMarkers?: string[] | undefined;
     linkedIndexes?: string[] | undefined;
+    extends?: string[] | undefined;
     strategyRoot?: string | undefined;
     partitions?: Record<string, string[]> | undefined;
     garbageCollection?: {
@@ -1448,7 +1490,7 @@ export declare const TotemConfigSchema: z.ZodObject<{
     targets: {
         type: "code" | "session_log" | "spec" | "lesson";
         glob: string;
-        strategy: "typescript-ast" | "markdown-heading" | "session-log" | "schema-file" | "test-file";
+        strategy: string;
     }[];
     secrets?: {
         value: string;
@@ -1484,6 +1526,7 @@ export declare const TotemConfigSchema: z.ZodObject<{
     repositories?: string[] | undefined;
     botMarkers?: string[] | undefined;
     linkedIndexes?: string[] | undefined;
+    extends?: string[] | undefined;
     strategyRoot?: string | undefined;
     partitions?: Record<string, string[]> | undefined;
     shieldAutoLearn?: boolean | undefined;
@@ -1522,7 +1565,15 @@ export declare const TotemConfigSchema: z.ZodObject<{
         }, z.ZodTypeAny, "passthrough">>>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
 }>;
-export type ChunkStrategy = z.infer<typeof ChunkStrategySchema>;
+/**
+ * `ChunkStrategy` keeps the literal union of built-in strategy names for
+ * IntelliSense on core code paths while admitting any string registered
+ * via Pack registration callbacks at boot. The Zod schema validates the
+ * runtime value against the registry; this type alias lives independently
+ * so callers don't lose type safety on built-in names. Per ADR-097 § 10 +
+ * mmnto-ai/totem#1769.
+ */
+export type ChunkStrategy = (typeof BUILTIN_CHUNK_STRATEGIES)[number] | (string & {});
 export type ContentType = z.infer<typeof ContentTypeSchema>;
 export type IngestTarget = z.infer<typeof IngestTargetSchema>;
 export type EmbeddingProvider = z.infer<typeof EmbeddingProviderSchema>;

package/dist/config-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config-schema.d.ts","sourceRoot":"","sources":["../src/config-schema.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"config-schema.d.ts","sourceRoot":"","sources":["../src/config-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;GAEG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,4FAM3B,CAAC;AAEX;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,mBAAmB,aAAoB,CAAC;AAErD,eAAO,MAAM,iBAAiB,sDAAoD,CAAC;AAEnF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAI7B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;EAI/B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;EAK/B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;EAI/B,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIlC,CAAC;AAEH,eAAO,MAAM,uBAAuB,UAUnC,CAAC;AAwCF,eAAO,MAAM,uBAAuB;IAlClC,kDAAkD;;IAElD,4FAA4F;;IAE5F,+EAA+E;;IAE/E,gFAAgF;;IAEhF;;;;;;;;;OASG;;IAEH;;;;;;;;;;;OAWG;;;IAMH,yDAAyD;;;;;;;;;;;;;;;;;;;;EAGzD,CAAC;AAEH,eAAO,MAAM,wBAAwB;IAzCnC,kDAAkD;;IAElD,4FAA4F;;IAE5F,+EAA+E;;IAE/E,gFAAgF;;IAEhF;;;;;;;;;OASG;;IAEH;;;;;;;;;;;OAWG;;;;;;;;;;;;;;;;;;;EAcH,CAAC;AAEH,eAAO,MAAM,2BAA2B;IA9CtC,kDAAkD;;IAElD,4FAA4F;;IAE5F,+EAA+E;;IAE/E,gFAAgF;;IAEhF;;;;;;;;;OASG;;IAEH;;;;;;;;;;;OAWG;;;;;;;;;;;;;;;;;;;EAmBH,CAAC;AAEH,eAAO,MAAM,wBAAwB;IAnDnC,kDAAkD;;IAElD,4FAA4F;;IAE5F,+EAA+E;;IAE/E,gFAAgF;;IAEhF;;;;;;;;;OASG;;IAEH;;;;;;;;;;;OAWG;;;IAuBH,gFAAgF;;;;;;;;;;;;;;;;;;;;EAGhF,CAAC;AAEH,eAAO,MAAM,wBAAwB;IA1DnC,kDAAkD;;IAElD,4FAA4F;;IAE5F,+EAA+E;;IAE/E,gFAAgF;;IAEhF;;;;;;;;;OASG;;IAEH;;;;;;;;;;;OAWG;;;IA8BH,qCAAqC;;IAErC,kFAAkF;;;;;;;;;;;;;;;;;;;;;;EAGlF,CAAC;AAEH,eAAO,MAAM,kBAAkB;IAnE7B,kDAAkD;;IAElD,4FAA4F;;IAE5F,+EAA+E;;IAE/E,gFAAgF;;IAEhF;;;;;;;;;OASG;;IAEH;;;;;;;;;;;OAWG;;;IAMH,yDAAyD;;;;;;;;;;;;;;;;;;;;;IApCzD,kDAAkD;;IAElD,4FAA4F;;IAE5F,+EAA+E;;IAE/E,gFAAgF;;IAEhF;;;;;;;;;OASG;;IAEH;;;;;;;;;;;OAWG;;;;;;;;;;;;;;;;;;;;IA9BH,kDAAkD;;IAElD,4FAA4F;;IAE5F,+EAA+E;;IAE/E,gFAAgF;;IAEhF;;;;;;;;;OASG;;IAEH;;;;;;;;;;;OAWG;;;;;;;;;;;;;;;;;;;;IA9BH,kDAAkD;;IAElD,4FAA4F;;IAE5F,+EAA+E;;IAE/E,gFAAgF;;IAEhF;;;;;;;;;OASG;;IAEH;;;;;;;;;;;OAWG;;;IAuBH,gFAAgF;;;;;;;;;;;;;;;;;;;;;IArDhF,kDAAkD;;IAElD,4FAA4F;;IAE5F,+EAA+E;;IAE/E,gFAAgF;;IAEhF;;;;;;;;;OASG;;IAEH;;;;;;;;;;;OAWG;;;IA8BH,qCAAqC;;IAErC,kFAAkF;;;;;;;;;;;;;;;;;;;;;;IAWlF,CAAC;AAmBH,eAAO,MAAM,uBAAuB;IAClC,4CAA4C;;IAE5C,uEAAuE;;IAEvE,kFAAkF;;;;;;;;;;EAIlF,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;IAE3B;;;;;;;;OAQG;;;;;;GAGO,CAAC;AAEf,eAAO,MAAM,eAAe;IAC1B,oCAAoC;;IAEpC,yEAAyE;;IAEzE,6DAA6D;;IAE7D,uJAAuJ;;;;;;;;;;;;EAEvJ,CAAC;AAEH,eAAO,MAAM,gBAAgB,yCAAuC,CAAC;AACrE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;;;GAIG;AACH,eAAO,MAAM,gCAAgC,yCAA0C,CAAC;AAExF;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,yEAMrC,CAAC;AAaJ,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;gCAgCnC,CAAC;AAEL,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCASjB,CAAC;AAEf,eAAO,MAAM,iBAAiB;IAC5B,mEAAmE;;;;;;;;;;;;;;IAGnE,gEAAgE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGhE,iEAAiE;;QA/NjE,kDAAkD;;QAElD,4FAA4F;;QAE5F,+EAA+E;;QAE/E,gFAAgF;;QAEhF;;;;;;;;;WASG;;QAEH;;;;;;;;;;;WAWG;;;QAMH,yDAAyD;;;;;;;;;;;;;;;;;;;;;QApCzD,kDAAkD;;QAElD,4FAA4F;;QAE5F,+EAA+E;;QAE/E,gFAAgF;;QAEhF;;;;;;;;;WASG;;QAEH;;;;;;;;;;;WAWG;;;;;;;;;;;;;;;;;;;;QA9BH,kDAAkD;;QAElD,4FAA4F;;QAE5F,+EAA+E;;QAE/E,gFAAgF;;QAEhF;;;;;;;;;WASG;;QAEH;;;;;;;;;;;WAWG;;;;;;;;;;;;;;;;;;;;QA9BH,kDAAkD;;QAElD,4FAA4F;;QAE5F,+EAA+E;;QAE/E,gFAAgF;;QAEhF;;;;;;;;;WASG;;QAEH;;;;;;;;;;;WAWG;;;QAuBH,gFAAgF;;;;;;;;;;;;;;;;;;;;;QArDhF,kDAAkD;;QAElD,4FAA4F;;QAE5F,+EAA+E;;QAE/E,gFAAgF;;QAEhF;;;;;;;;;WASG;;QAEH;;;;;;;;;;;WAWG;;;QA8BH,qCAAqC;;QAErC,kFAAkF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoKlF,oDAAoD;;IAMpD,sDAAsD;;IAMtD,uDAAuD;;IAGvD,oHAAoH;;IAGpH,sHAAsH;;IAGtH,0DAA0D;;QA3H1D,oCAAoC;;QAEpC,yEAAyE;;QAEzE,6DAA6D;;QAE7D,uJAAuJ;;;;;;;;;;;;;IAwHvJ,8GAA8G;;IAG9G,mGAAmG;;IAGnG,0IAA0I;;IAG1I,kJAAkJ;;IAGlJ;;;;;;;;;;;OAWG;;IAGH;;;;;;;;;;;OAWG;;IAGH,kKAAkK;;IAGlK,sFAAsF;;;;;;;;;;;IAGtF,wFAAwF;;IAGxF,qEAAqE;;QA9MrE,4CAA4C;;QAE5C,uEAAuE;;QAEvE,kFAAkF;;;;;;;;;;;IA6MlF,4EAA4E;;QAhM1E;;;;;;;;WAQG;;;;;;;IA2LL;wFACoF;;;;;;;;;;;IAWpF,oDAAoD;;QAGhD;gGACwF;;;;;;;IAK5F;;;iFAG6E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7E,CAAC;AAEH;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;AACtF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAC9E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D;;;GAGG;AACH,eAAO,MAAM,YAAY,uEAAwE,CAAC;AAElG;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,WAAW,GAAG,UAAU,CAI7D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,WAAW,GAAG,iBAAiB,CAQvE"}