@ai-coders/context 0.4.0 → 0.5.1

package/dist/fragments/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Context Fragment System
+ *
+ * Atomic, typed pieces of context that AI can query, filter, and compose freely.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   createFragmentStore,
+ *   createExtractorRegistry,
+ *   queryFrom,
+ *   createComposer,
+ *   renderFragments,
+ * } from './fragments';
+ *
+ * // Create store and extract fragments
+ * const store = createFragmentStore();
+ * const registry = createExtractorRegistry();
+ * const fragments = registry.extractAll({ repoStructure, semantics });
+ * store.addAll(fragments);
+ *
+ * // Query fragments
+ * const types = queryFrom(store)
+ *   .ofType('type-definition')
+ *   .withTags('exported')
+ *   .orderByPriority()
+ *   .limit(10)
+ *   .execute();
+ *
+ * // Compose context for a task
+ * const composer = createComposer(store);
+ * const context = composer.forTask('Add user authentication', 8000);
+ *
+ * // Render to output format
+ * const markdown = renderFragments(context, 'markdown');
+ * const json = renderFragments(context, 'json');
+ * const compact = renderFragments(context, 'compact');
+ * ```
+ */
+export type { FragmentType, FragmentScope, ContextFragment, FragmentRefs, FragmentMeta, ProjectOverviewData, ModuleData, FileSummaryData, TypeDefinitionData, FunctionData, ApiEndpointData, ComponentData, DependencyGraphData, PatternData, ConventionData, ConfigData, CommandData, ProjectOverviewFragment, ModuleFragment, FileSummaryFragment, TypeDefinitionFragment, FunctionFragment, ApiEndpointFragment, ComponentFragment, DependencyGraphFragment, PatternFragment, ConventionFragment, ConfigFragment, CommandFragment, FragmentQuery, CompositionStrategy, CompositionOptions, RenderFormat, RenderOptions, FragmentStore, FragmentExtractor, } from './types.js';
+export { InMemoryFragmentStore, createFragmentStore } from './store.js';
+export { FragmentQueryBuilder, queryFrom, getEssentialContext, getTypesForFile, getFunctionsForFile, getApiEndpoints, getPatternsAndConventions, getContextForSymbol, getModuleContext, } from './query.js';
+export { composeFragments, createComposer } from './compose.js';
+export { renderFragments, getAvailableFormats, renderMarkdown, renderJSON, renderCompact, } from './render/index.js';
+export { createExtractorRegistry, extractProjectFragments, extractModuleFragments, extractSemanticFragments, } from './extractors/index.js';
+export type { ExtractionInput, ExtractorRegistry } from './extractors/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/fragments/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fragments/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAGH,YAAY,EACV,YAAY,EACZ,aAAa,EACb,eAAe,EACf,YAAY,EACZ,YAAY,EACZ,mBAAmB,EACnB,UAAU,EACV,eAAe,EACf,kBAAkB,EAClB,YAAY,EACZ,eAAe,EACf,aAAa,EACb,mBAAmB,EACnB,WAAW,EACX,cAAc,EACd,UAAU,EACV,WAAW,EACX,uBAAuB,EACvB,cAAc,EACd,mBAAmB,EACnB,sBAAsB,EACtB,gBAAgB,EAChB,mBAAmB,EACnB,iBAAiB,EACjB,uBAAuB,EACvB,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,eAAe,EACf,aAAa,EACb,mBAAmB,EACnB,kBAAkB,EAClB,YAAY,EACZ,aAAa,EACb,aAAa,EACb,iBAAiB,GAClB,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAGxE,OAAO,EACL,oBAAoB,EACpB,SAAS,EACT,mBAAmB,EACnB,eAAe,EACf,mBAAmB,EACnB,eAAe,EACf,yBAAyB,EACzB,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAGhE,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,cAAc,EACd,UAAU,EACV,aAAa,GACd,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACL,uBAAuB,EACvB,uBAAuB,EACvB,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/fragments/index.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * Context Fragment System
+ *
+ * Atomic, typed pieces of context that AI can query, filter, and compose freely.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   createFragmentStore,
+ *   createExtractorRegistry,
+ *   queryFrom,
+ *   createComposer,
+ *   renderFragments,
+ * } from './fragments';
+ *
+ * // Create store and extract fragments
+ * const store = createFragmentStore();
+ * const registry = createExtractorRegistry();
+ * const fragments = registry.extractAll({ repoStructure, semantics });
+ * store.addAll(fragments);
+ *
+ * // Query fragments
+ * const types = queryFrom(store)
+ *   .ofType('type-definition')
+ *   .withTags('exported')
+ *   .orderByPriority()
+ *   .limit(10)
+ *   .execute();
+ *
+ * // Compose context for a task
+ * const composer = createComposer(store);
+ * const context = composer.forTask('Add user authentication', 8000);
+ *
+ * // Render to output format
+ * const markdown = renderFragments(context, 'markdown');
+ * const json = renderFragments(context, 'json');
+ * const compact = renderFragments(context, 'compact');
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractSemanticFragments = exports.extractModuleFragments = exports.extractProjectFragments = exports.createExtractorRegistry = exports.renderCompact = exports.renderJSON = exports.renderMarkdown = exports.getAvailableFormats = exports.renderFragments = exports.createComposer = exports.composeFragments = exports.getModuleContext = exports.getContextForSymbol = exports.getPatternsAndConventions = exports.getApiEndpoints = exports.getFunctionsForFile = exports.getTypesForFile = exports.getEssentialContext = exports.queryFrom = exports.FragmentQueryBuilder = exports.createFragmentStore = exports.InMemoryFragmentStore = void 0;
+// Store
+var store_js_1 = require("./store.js");
+Object.defineProperty(exports, "InMemoryFragmentStore", { enumerable: true, get: function () { return store_js_1.InMemoryFragmentStore; } });
+Object.defineProperty(exports, "createFragmentStore", { enumerable: true, get: function () { return store_js_1.createFragmentStore; } });
+// Query
+var query_js_1 = require("./query.js");
+Object.defineProperty(exports, "FragmentQueryBuilder", { enumerable: true, get: function () { return query_js_1.FragmentQueryBuilder; } });
+Object.defineProperty(exports, "queryFrom", { enumerable: true, get: function () { return query_js_1.queryFrom; } });
+Object.defineProperty(exports, "getEssentialContext", { enumerable: true, get: function () { return query_js_1.getEssentialContext; } });
+Object.defineProperty(exports, "getTypesForFile", { enumerable: true, get: function () { return query_js_1.getTypesForFile; } });
+Object.defineProperty(exports, "getFunctionsForFile", { enumerable: true, get: function () { return query_js_1.getFunctionsForFile; } });
+Object.defineProperty(exports, "getApiEndpoints", { enumerable: true, get: function () { return query_js_1.getApiEndpoints; } });
+Object.defineProperty(exports, "getPatternsAndConventions", { enumerable: true, get: function () { return query_js_1.getPatternsAndConventions; } });
+Object.defineProperty(exports, "getContextForSymbol", { enumerable: true, get: function () { return query_js_1.getContextForSymbol; } });
+Object.defineProperty(exports, "getModuleContext", { enumerable: true, get: function () { return query_js_1.getModuleContext; } });
+// Composition
+var compose_js_1 = require("./compose.js");
+Object.defineProperty(exports, "composeFragments", { enumerable: true, get: function () { return compose_js_1.composeFragments; } });
+Object.defineProperty(exports, "createComposer", { enumerable: true, get: function () { return compose_js_1.createComposer; } });
+// Renderers
+var index_js_1 = require("./render/index.js");
+Object.defineProperty(exports, "renderFragments", { enumerable: true, get: function () { return index_js_1.renderFragments; } });
+Object.defineProperty(exports, "getAvailableFormats", { enumerable: true, get: function () { return index_js_1.getAvailableFormats; } });
+Object.defineProperty(exports, "renderMarkdown", { enumerable: true, get: function () { return index_js_1.renderMarkdown; } });
+Object.defineProperty(exports, "renderJSON", { enumerable: true, get: function () { return index_js_1.renderJSON; } });
+Object.defineProperty(exports, "renderCompact", { enumerable: true, get: function () { return index_js_1.renderCompact; } });
+// Extractors
+var index_js_2 = require("./extractors/index.js");
+Object.defineProperty(exports, "createExtractorRegistry", { enumerable: true, get: function () { return index_js_2.createExtractorRegistry; } });
+Object.defineProperty(exports, "extractProjectFragments", { enumerable: true, get: function () { return index_js_2.extractProjectFragments; } });
+Object.defineProperty(exports, "extractModuleFragments", { enumerable: true, get: function () { return index_js_2.extractModuleFragments; } });
+Object.defineProperty(exports, "extractSemanticFragments", { enumerable: true, get: function () { return index_js_2.extractSemanticFragments; } });
+//# sourceMappingURL=index.js.map

package/dist/fragments/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/fragments/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;;;AA0CH,QAAQ;AACR,uCAAwE;AAA/D,iHAAA,qBAAqB,OAAA;AAAE,+GAAA,mBAAmB,OAAA;AAEnD,QAAQ;AACR,uCAUoB;AATlB,gHAAA,oBAAoB,OAAA;AACpB,qGAAA,SAAS,OAAA;AACT,+GAAA,mBAAmB,OAAA;AACnB,2GAAA,eAAe,OAAA;AACf,+GAAA,mBAAmB,OAAA;AACnB,2GAAA,eAAe,OAAA;AACf,qHAAA,yBAAyB,OAAA;AACzB,+GAAA,mBAAmB,OAAA;AACnB,4GAAA,gBAAgB,OAAA;AAGlB,cAAc;AACd,2CAAgE;AAAvD,8GAAA,gBAAgB,OAAA;AAAE,4GAAA,cAAc,OAAA;AAEzC,YAAY;AACZ,8CAM2B;AALzB,2GAAA,eAAe,OAAA;AACf,+GAAA,mBAAmB,OAAA;AACnB,0GAAA,cAAc,OAAA;AACd,sGAAA,UAAU,OAAA;AACV,yGAAA,aAAa,OAAA;AAGf,aAAa;AACb,kDAK+B;AAJ7B,mHAAA,uBAAuB,OAAA;AACvB,mHAAA,uBAAuB,OAAA;AACvB,kHAAA,sBAAsB,OAAA;AACtB,oHAAA,wBAAwB,OAAA"}

package/dist/fragments/query.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Query Builder - Fluent API for querying fragments
+ */
+import type { ContextFragment, FragmentQuery, FragmentScope, FragmentStore, FragmentType } from './types.js';
+/**
+ * Fluent query builder for fragments
+ */
+export declare class FragmentQueryBuilder {
+    private store;
+    private queryDef;
+    constructor(store: FragmentStore);
+    /**
+     * Filter by fragment types
+     */
+    ofType(...types: FragmentType[]): this;
+    /**
+     * Filter by scope
+     */
+    inScope(...scopes: FragmentScope[]): this;
+    /**
+     * Include fragments with any of these tags
+     */
+    withTags(...tags: string[]): this;
+    /**
+     * Exclude fragments with any of these tags
+     */
+    withoutTags(...tags: string[]): this;
+    /**
+     * Filter by related files (partial path matching)
+     */
+    relatedToFiles(...patterns: string[]): this;
+    /**
+     * Filter by related symbols
+     */
+    relatedToSymbols(...symbols: string[]): this;
+    /**
+     * Order results by priority (highest first)
+     */
+    orderByPriority(): this;
+    /**
+     * Order results by freshness (newest first)
+     */
+    orderByFreshness(): this;
+    /**
+     * Order results by relevance
+     */
+    orderByRelevance(): this;
+    /**
+     * Limit number of results
+     */
+    limit(n: number): this;
+    /**
+     * Execute the query and return results
+     */
+    execute(): ContextFragment<unknown>[];
+    /**
+     * Execute and return first result
+     */
+    first(): ContextFragment<unknown> | undefined;
+    /**
+     * Execute and return count
+     */
+    count(): number;
+    /**
+     * Get the raw query definition
+     */
+    toQuery(): FragmentQuery;
+}
+/**
+ * Create a query builder for a store
+ */
+export declare function queryFrom(store: FragmentStore): FragmentQueryBuilder;
+/**
+ * Get essential project context (overview + high priority)
+ */
+export declare function getEssentialContext(store: FragmentStore): ContextFragment<unknown>[];
+/**
+ * Get type definitions for a file
+ */
+export declare function getTypesForFile(store: FragmentStore, filePath: string): ContextFragment<unknown>[];
+/**
+ * Get functions for a file
+ */
+export declare function getFunctionsForFile(store: FragmentStore, filePath: string): ContextFragment<unknown>[];
+/**
+ * Get all API endpoints
+ */
+export declare function getApiEndpoints(store: FragmentStore): ContextFragment<unknown>[];
+/**
+ * Get patterns and conventions
+ */
+export declare function getPatternsAndConventions(store: FragmentStore): ContextFragment<unknown>[];
+/**
+ * Get context related to a specific symbol
+ */
+export declare function getContextForSymbol(store: FragmentStore, symbol: string): ContextFragment<unknown>[];
+/**
+ * Get module-level context
+ */
+export declare function getModuleContext(store: FragmentStore, modulePath: string): ContextFragment<unknown>[];
+//# sourceMappingURL=query.d.ts.map

package/dist/fragments/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/fragments/query.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EACV,eAAe,EACf,aAAa,EACb,aAAa,EACb,aAAa,EACb,YAAY,EACb,MAAM,YAAY,CAAC;AAEpB;;GAEG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,QAAQ,CAAqB;gBAEzB,KAAK,EAAE,aAAa;IAIhC;;OAEG;IACH,MAAM,CAAC,GAAG,KAAK,EAAE,YAAY,EAAE,GAAG,IAAI;IAKtC;;OAEG;IACH,OAAO,CAAC,GAAG,MAAM,EAAE,aAAa,EAAE,GAAG,IAAI;IAKzC;;OAEG;IACH,QAAQ,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI;IAQjC;;OAEG;IACH,WAAW,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI;IAQpC;;OAEG;IACH,cAAc,CAAC,GAAG,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI;IAQ3C;;OAEG;IACH,gBAAgB,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI;IAQ5C;;OAEG;IACH,eAAe,IAAI,IAAI;IAKvB;;OAEG;IACH,gBAAgB,IAAI,IAAI;IAKxB;;OAEG;IACH,gBAAgB,IAAI,IAAI;IAKxB;;OAEG;IACH,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAKtB;;OAEG;IACH,OAAO,IAAI,eAAe,CAAC,OAAO,CAAC,EAAE;IAIrC;;OAEG;IACH,KAAK,IAAI,eAAe,CAAC,OAAO,CAAC,GAAG,SAAS;IAI7C;;OAEG;IACH,KAAK,IAAI,MAAM;IAIf;;OAEG;IACH,OAAO,IAAI,aAAa;CAGzB;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,aAAa,GAAG,oBAAoB,CAEpE;AAID;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa,GAAG,eAAe,CAAC,OAAO,CAAC,EAAE,CAKpF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,MAAM,GACf,eAAe,CAAC,OAAO,CAAC,EAAE,CAM5B;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,MAAM,GACf,eAAe,CAAC,OAAO,CAAC,EAAE,CAM5B;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa,GAAG,eAAe,CAAC,OAAO,CAAC,EAAE,CAEhF;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,aAAa,GACnB,eAAe,CAAC,OAAO,CAAC,EAAE,CAK5B;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,MAAM,GACb,eAAe,CAAC,OAAO,CAAC,EAAE,CAK5B;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,aAAa,EACpB,UAAU,EAAE,MAAM,GACjB,eAAe,CAAC,OAAO,CAAC,EAAE,CAK5B"}

package/dist/fragments/query.js

@@ -0,0 +1,200 @@
+"use strict";
+/**
+ * Query Builder - Fluent API for querying fragments
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FragmentQueryBuilder = void 0;
+exports.queryFrom = queryFrom;
+exports.getEssentialContext = getEssentialContext;
+exports.getTypesForFile = getTypesForFile;
+exports.getFunctionsForFile = getFunctionsForFile;
+exports.getApiEndpoints = getApiEndpoints;
+exports.getPatternsAndConventions = getPatternsAndConventions;
+exports.getContextForSymbol = getContextForSymbol;
+exports.getModuleContext = getModuleContext;
+/**
+ * Fluent query builder for fragments
+ */
+class FragmentQueryBuilder {
+    constructor(store) {
+        this.queryDef = {};
+        this.store = store;
+    }
+    /**
+     * Filter by fragment types
+     */
+    ofType(...types) {
+        this.queryDef.types = types;
+        return this;
+    }
+    /**
+     * Filter by scope
+     */
+    inScope(...scopes) {
+        this.queryDef.scope = scopes;
+        return this;
+    }
+    /**
+     * Include fragments with any of these tags
+     */
+    withTags(...tags) {
+        this.queryDef.tags = {
+            ...this.queryDef.tags,
+            include: tags,
+        };
+        return this;
+    }
+    /**
+     * Exclude fragments with any of these tags
+     */
+    withoutTags(...tags) {
+        this.queryDef.tags = {
+            ...this.queryDef.tags,
+            exclude: tags,
+        };
+        return this;
+    }
+    /**
+     * Filter by related files (partial path matching)
+     */
+    relatedToFiles(...patterns) {
+        this.queryDef.relatedTo = {
+            ...this.queryDef.relatedTo,
+            files: patterns,
+        };
+        return this;
+    }
+    /**
+     * Filter by related symbols
+     */
+    relatedToSymbols(...symbols) {
+        this.queryDef.relatedTo = {
+            ...this.queryDef.relatedTo,
+            symbols: symbols,
+        };
+        return this;
+    }
+    /**
+     * Order results by priority (highest first)
+     */
+    orderByPriority() {
+        this.queryDef.orderBy = 'priority';
+        return this;
+    }
+    /**
+     * Order results by freshness (newest first)
+     */
+    orderByFreshness() {
+        this.queryDef.orderBy = 'freshness';
+        return this;
+    }
+    /**
+     * Order results by relevance
+     */
+    orderByRelevance() {
+        this.queryDef.orderBy = 'relevance';
+        return this;
+    }
+    /**
+     * Limit number of results
+     */
+    limit(n) {
+        this.queryDef.limit = n;
+        return this;
+    }
+    /**
+     * Execute the query and return results
+     */
+    execute() {
+        return this.store.query(this.queryDef);
+    }
+    /**
+     * Execute and return first result
+     */
+    first() {
+        return this.limit(1).execute()[0];
+    }
+    /**
+     * Execute and return count
+     */
+    count() {
+        return this.execute().length;
+    }
+    /**
+     * Get the raw query definition
+     */
+    toQuery() {
+        return { ...this.queryDef };
+    }
+}
+exports.FragmentQueryBuilder = FragmentQueryBuilder;
+/**
+ * Create a query builder for a store
+ */
+function queryFrom(store) {
+    return new FragmentQueryBuilder(store);
+}
+// Predefined query helpers
+/**
+ * Get essential project context (overview + high priority)
+ */
+function getEssentialContext(store) {
+    return queryFrom(store)
+        .ofType('project-overview', 'module', 'config')
+        .orderByPriority()
+        .execute();
+}
+/**
+ * Get type definitions for a file
+ */
+function getTypesForFile(store, filePath) {
+    return queryFrom(store)
+        .ofType('type-definition')
+        .relatedToFiles(filePath)
+        .orderByPriority()
+        .execute();
+}
+/**
+ * Get functions for a file
+ */
+function getFunctionsForFile(store, filePath) {
+    return queryFrom(store)
+        .ofType('function')
+        .relatedToFiles(filePath)
+        .orderByPriority()
+        .execute();
+}
+/**
+ * Get all API endpoints
+ */
+function getApiEndpoints(store) {
+    return queryFrom(store).ofType('api-endpoint').orderByPriority().execute();
+}
+/**
+ * Get patterns and conventions
+ */
+function getPatternsAndConventions(store) {
+    return queryFrom(store)
+        .ofType('pattern', 'convention')
+        .orderByPriority()
+        .execute();
+}
+/**
+ * Get context related to a specific symbol
+ */
+function getContextForSymbol(store, symbol) {
+    return queryFrom(store)
+        .relatedToSymbols(symbol)
+        .orderByPriority()
+        .execute();
+}
+/**
+ * Get module-level context
+ */
+function getModuleContext(store, modulePath) {
+    return queryFrom(store)
+        .relatedToFiles(modulePath)
+        .orderByPriority()
+        .execute();
+}
+//# sourceMappingURL=query.js.map

package/dist/fragments/query.js.map

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

package/dist/fragments/render/compact.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Compact Renderer - Token-efficient output for AI consumption
+ *
+ * Uses abbreviated format to maximize information density while
+ * remaining parseable by AI systems.
+ */
+import type { ContextFragment, RenderOptions } from '../types.js';
+/**
+ * Render fragments in compact format
+ *
+ * Format:
+ * [TYPE:name] summary | key:value | key:value
+ */
+export declare function renderCompact(fragments: ContextFragment<unknown>[], options?: Partial<RenderOptions>): string;
+//# sourceMappingURL=compact.d.ts.map

package/dist/fragments/render/compact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compact.d.ts","sourceRoot":"","sources":["../../../src/fragments/render/compact.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAElE;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,eAAe,CAAC,OAAO,CAAC,EAAE,EACrC,OAAO,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,GAC/B,MAAM,CAqBR"}

package/dist/fragments/render/compact.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * Compact Renderer - Token-efficient output for AI consumption
+ *
+ * Uses abbreviated format to maximize information density while
+ * remaining parseable by AI systems.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderCompact = renderCompact;
+/**
+ * Render fragments in compact format
+ *
+ * Format:
+ * [TYPE:name] summary | key:value | key:value
+ */
+function renderCompact(fragments, options) {
+    const lines = [];
+    // Header
+    lines.push(`# Context (${fragments.length} fragments)`);
+    lines.push('');
+    // Group by type for organization
+    const grouped = groupByType(fragments);
+    for (const [type, typeFragments] of grouped) {
+        lines.push(`## ${abbreviateType(type)}`);
+        for (const fragment of typeFragments) {
+            lines.push(renderCompactFragment(fragment));
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+function groupByType(fragments) {
+    const grouped = new Map();
+    for (const fragment of fragments) {
+        const existing = grouped.get(fragment.type) || [];
+        existing.push(fragment);
+        grouped.set(fragment.type, existing);
+    }
+    return grouped;
+}
+function renderCompactFragment(fragment) {
+    const parts = [];
+    // [TYPE:name]
+    const name = extractName(fragment);
+    parts.push(`[${abbreviateType(fragment.type)}:${name}]`);
+    // Core data based on type
+    parts.push(extractCoreData(fragment));
+    // Priority if high
+    if (fragment.meta.priority >= 8) {
+        parts.push(`P${fragment.meta.priority}`);
+    }
+    // Key files (abbreviated)
+    if (fragment.refs.files.length > 0) {
+        const mainFile = abbreviatePath(fragment.refs.files[0]);
+        parts.push(`@${mainFile}`);
+    }
+    return parts.filter(Boolean).join(' | ');
+}
+function extractName(fragment) {
+    const data = fragment.data;
+    if (data && typeof data === 'object') {
+        if ('name' in data && typeof data.name === 'string') {
+            return data.name;
+        }
+        if ('path' in data && typeof data.path === 'string') {
+            return abbreviatePath(data.path);
+        }
+    }
+    return fragment.id.slice(0, 20);
+}
+function extractCoreData(fragment) {
+    const data = fragment.data;
+    switch (fragment.type) {
+        case 'project-overview':
+            return compactProject(data);
+        case 'module':
+            return compactModule(data);
+        case 'type-definition':
+            return compactType(data);
+        case 'function':
+            return compactFunction(data);
+        case 'config':
+            return compactConfig(data);
+        case 'command':
+            return compactCommand(data);
+        case 'pattern':
+            return compactPattern(data);
+        case 'file-summary':
+            return compactFile(data);
+        default:
+            return fragment.summary || '';
+    }
+}
+function compactProject(data) {
+    const parts = [];
+    if (Array.isArray(data.languages)) {
+        parts.push(`lang:${data.languages.join(',')}`);
+    }
+    if (data.packageManager) {
+        parts.push(`pm:${data.packageManager}`);
+    }
+    if (Array.isArray(data.entryPoints) && data.entryPoints.length > 0) {
+        parts.push(`entry:${abbreviatePath(data.entryPoints[0])}`);
+    }
+    return parts.join(' ');
+}
+function compactModule(data) {
+    const parts = [];
+    if (Array.isArray(data.exports)) {
+        parts.push(`exp:${data.exports.length}`);
+    }
+    if (Array.isArray(data.dependencies)) {
+        parts.push(`dep:${data.dependencies.length}`);
+    }
+    if (data.description) {
+        parts.push(truncate(data.description, 30));
+    }
+    return parts.join(' ');
+}
+function compactType(data) {
+    const parts = [];
+    parts.push(`${data.kind}`);
+    if (Array.isArray(data.properties)) {
+        parts.push(`props:${data.properties.length}`);
+    }
+    if (Array.isArray(data.methods)) {
+        parts.push(`methods:${data.methods.length}`);
+    }
+    if (Array.isArray(data.extends) && data.extends.length > 0) {
+        parts.push(`<${data.extends[0]}`);
+    }
+    return parts.join(' ');
+}
+function compactFunction(data) {
+    const parts = [];
+    if (data.async)
+        parts.push('async');
+    if (data.exported)
+        parts.push('exp');
+    // Signature (abbreviated)
+    if (data.signature) {
+        const sig = data.signature
+            .replace(/function\s+/, '')
+            .replace(/\s+/g, '');
+        parts.push(truncate(sig, 40));
+    }
+    return parts.join(' ');
+}
+function compactConfig(data) {
+    return `${data.format} ${truncate(data.purpose || '', 30)}`;
+}
+function compactCommand(data) {
+    return truncate(data.command, 50);
+}
+function compactPattern(data) {
+    const parts = [];
+    parts.push(truncate(data.description, 40));
+    if (Array.isArray(data.locations)) {
+        parts.push(`(${data.locations.length} locs)`);
+    }
+    return parts.join(' ');
+}
+function compactFile(data) {
+    const parts = [];
+    parts.push(data.language);
+    if (Array.isArray(data.exports) && data.exports.length > 0) {
+        parts.push(`exp:${data.exports.slice(0, 3).join(',')}`);
+    }
+    if (data.purpose) {
+        parts.push(truncate(data.purpose, 30));
+    }
+    return parts.join(' ');
+}
+function abbreviateType(type) {
+    const abbrevs = {
+        'project-overview': 'PROJ',
+        module: 'MOD',
+        'file-summary': 'FILE',
+        'type-definition': 'TYPE',
+        function: 'FUNC',
+        'api-endpoint': 'API',
+        component: 'COMP',
+        'dependency-graph': 'DEPS',
+        'data-flow': 'FLOW',
+        'call-graph': 'CALL',
+        pattern: 'PAT',
+        convention: 'CONV',
+        example: 'EX',
+        config: 'CFG',
+        environment: 'ENV',
+        command: 'CMD',
+    };
+    return abbrevs[type] || type.toUpperCase().slice(0, 4);
+}
+function abbreviatePath(filePath) {
+    // Remove common prefixes and truncate
+    return filePath
+        .replace(/^src\//, '')
+        .replace(/^lib\//, '')
+        .replace(/\.ts$/, '')
+        .replace(/\.js$/, '')
+        .replace(/\/index$/, '/');
+}
+function truncate(str, maxLen) {
+    if (str.length <= maxLen)
+        return str;
+    return str.slice(0, maxLen - 3) + '...';
+}
+//# sourceMappingURL=compact.js.map