@vpxa/aikit 0.1.59 → 0.1.60

package/packages/store/dist/store.interface.d.ts

@@ -1,54 +0,0 @@
-import { ContentType, IndexStats, KnowledgeOrigin, KnowledgeRecord, SearchResult, SourceType } from "../../core/dist/index.js";
-
-//#region packages/store/src/store.interface.d.ts
-/** Options for searching the store */
-interface SearchOptions {
-  /** Maximum number of results to return */
-  limit?: number;
-  /** Minimum similarity score (0-1) */
-  minScore?: number;
-  /** Filter by content type */
-  contentType?: ContentType;
-  /** Filter by coarse source type (source, documentation, test, config, generated) */
-  sourceType?: SourceType;
-  /** Filter by origin */
-  origin?: KnowledgeOrigin;
-  /** Filter by category */
-  category?: string;
-  /** Filter by tags (any match) */
-  tags?: string[];
-}
-interface IKnowledgeStore {
-  /** Initialize the store (create tables, etc.) */
-  initialize(): Promise<void>;
-  /** Add or update records with their embedding vectors */
-  upsert(records: KnowledgeRecord[], vectors: Float32Array[]): Promise<void>;
-  /** Add or update records with priority over bulk indexing writes */
-  upsertInteractive(records: KnowledgeRecord[], vectors: Float32Array[]): Promise<void>;
-  /** Search by vector similarity */
-  search(queryVector: Float32Array, options?: SearchOptions): Promise<SearchResult[]>;
-  /** Get a specific record by ID */
-  getById(id: string): Promise<KnowledgeRecord | null>;
-  /** Delete records by source path (used during re-indexing) */
-  deleteBySourcePath(sourcePath: string): Promise<number>;
-  /** Delete a specific record by ID */
-  deleteById(id: string): Promise<boolean>;
-  /** Delete a specific record by ID with priority over bulk indexing writes */
-  deleteByIdInteractive(id: string): Promise<boolean>;
-  /** Get all records for a source path */
-  getBySourcePath(sourcePath: string): Promise<KnowledgeRecord[]>;
-  /** Get index statistics */
-  getStats(): Promise<IndexStats>;
-  /** List all unique source paths in the store */
-  listSourcePaths(): Promise<string[]>;
-  /** Create a full-text search index on the content column for keyword search */
-  createFtsIndex(): Promise<void>;
-  /** Full-text keyword search (requires FTS index) */
-  ftsSearch(query: string, options?: SearchOptions): Promise<SearchResult[]>;
-  /** Drop the backing table entirely — used for hard resets (e.g. dimension changes) */
-  dropTable(): Promise<void>;
-  /** Close the store connection */
-  close(): Promise<void>;
-}
-//#endregion
-export { IKnowledgeStore, SearchOptions };

package/packages/store/dist/store.interface.js

@@ -1 +0,0 @@
-export{};

package/packages/tools/dist/audit.d.ts

@@ -1,65 +0,0 @@
-import { KBResponse } from "./response-envelope.js";
-import { IEmbedder } from "../../embeddings/dist/index.js";
-import { IKnowledgeStore } from "../../store/dist/index.js";
-
-//#region packages/tools/src/audit.d.ts
-type AuditCheck = 'structure' | 'dependencies' | 'patterns' | 'health' | 'dead_symbols' | 'check' | 'entry_points';
-interface AuditOptions {
-  /** Root path to audit (default: cwd) */
-  path?: string;
-  /** Which checks to run (default: all) */
-  checks?: AuditCheck[];
-  /** Detail level (default: 'summary') */
-  detail?: 'summary' | 'full';
-}
-interface AuditRecommendation {
-  priority: 'high' | 'medium' | 'low';
-  area: string;
-  message: string;
-}
-interface AuditData {
-  score: number;
-  structure?: {
-    files: number;
-    packages: number;
-    languages: Record<string, number>;
-  };
-  dependencies?: {
-    external: number;
-    internal: number;
-  };
-  patterns?: Array<{
-    name: string;
-    confidence: string;
-    count: number;
-  }>;
-  health?: {
-    score: number;
-    checks: number;
-    passed: number;
-    warned: number;
-    failed: number;
-  };
-  deadSymbols?: {
-    source: number;
-    docs: number;
-  };
-  entryPoints?: {
-    total: number;
-    types: Record<string, number>;
-  };
-  typecheck?: {
-    passed: boolean;
-    errorCount: number;
-    topErrors: string[];
-  };
-  lint?: {
-    passed: boolean;
-    errorCount: number;
-    topErrors: string[];
-  };
-  recommendations: AuditRecommendation[];
-}
-declare function audit(store: IKnowledgeStore, embedder: IEmbedder, options?: AuditOptions): Promise<KBResponse<AuditData>>;
-//#endregion
-export { AuditCheck, AuditData, AuditOptions, AuditRecommendation, audit };

package/packages/tools/dist/audit.js

@@ -1,6 +0,0 @@
-import{check as e,summarizeCheckResult as t}from"./check.js";import{findDeadSymbols as n}from"./dead-symbols.js";import{health as r}from"./health.js";import{resolvePath as i}from"./path-resolver.js";import{errorResponse as a,okResponse as o}from"./response-envelope.js";import{DependencyAnalyzer as s,EntryPointAnalyzer as c,PatternAnalyzer as l,StructureAnalyzer as u}from"../../analyzers/dist/index.js";const d=[`structure`,`dependencies`,`patterns`,`health`,`dead_symbols`,`check`,`entry_points`];async function f(f,m,h={}){let g=Date.now(),_=i(h.path),v=h.checks??d,y=h.detail??`summary`,b=[],x={score:100,recommendations:b};try{let i=[];v.includes(`structure`)&&i.push((async()=>{let e=await new u().analyze(_,{format:`json`}),t=e.data;x.structure={files:t.stats?.totalFiles??e.meta.fileCount,packages:Array.isArray(t.packages)?t.packages.length:0,languages:t.stats?.languages??{}}})()),v.includes(`dependencies`)&&i.push((async()=>{let e=(await new s().analyze(_)).data,t=e.imports??[];x.dependencies={external:e.external?.length??t.filter(e=>e.isExternal).length,internal:e.internal?.length??t.filter(e=>!e.isExternal).length}})()),v.includes(`patterns`)&&i.push((async()=>{x.patterns=((await new l().analyze(_)).data.patterns??[]).map(e=>({name:e.pattern,confidence:e.confidence,count:e.locations.length}))})()),v.includes(`entry_points`)&&i.push((async()=>{let e=(await new c().analyze(_)).data,t=e.entryPoints??[],n={};for(let e of t)n[e.type]=(n[e.type]??0)+1;x.entryPoints={total:e.total??t.length,types:n}})()),v.includes(`health`)&&i.push((async()=>{let e=r(_);x.health={score:e.score,checks:e.checks.length,passed:e.checks.filter(e=>e.status===`pass`).length,warned:e.checks.filter(e=>e.status===`warn`).length,failed:e.checks.filter(e=>e.status===`fail`).length},e.score<70&&b.push({priority:`medium`,area:`health`,message:`Health score ${e.score}/100 — ${x.health.failed} failed checks`})})()),v.includes(`dead_symbols`)&&i.push((async()=>{let e=await n(m,f,{rootPath:_});x.deadSymbols={source:e.totalDeadSource,docs:e.totalDeadDocs},e.totalDeadSource>0&&b.push({priority:e.totalDeadSource>10?`high`:`medium`,area:`dead-code`,message:`${e.totalDeadSource} unused exports in source files`})})()),v.includes(`check`)&&i.push((async()=>{let n=t(await e({cwd:_}));x.typecheck={passed:n.tsc.passed,errorCount:n.tsc.errorCount,topErrors:n.tsc.topErrors},x.lint={passed:n.biome.passed,errorCount:n.biome.errorCount,topErrors:n.biome.topErrors},n.tsc.passed||b.push({priority:`high`,area:`type-safety`,message:`Fix ${n.tsc.errorCount} tsc error(s)`}),n.biome.passed||b.push({priority:`medium`,area:`lint`,message:`Fix ${n.biome.errorCount} lint error(s)`})})()),await Promise.all(i);let a=0;x.typecheck&&!x.typecheck.passed&&(a+=15),x.lint&&!x.lint.passed&&(a+=5),x.health&&x.health.score<80&&(a+=10),x.deadSymbols&&x.deadSymbols.source>10&&(a+=5),x.entryPoints&&x.entryPoints.total===0&&(a+=5),x.score=Math.max(0,100-a);let d={high:0,medium:1,low:2};b.sort((e,t)=>d[e.priority]-d[t.priority]);let h=p(x,y),S=[];return x.typecheck&&!x.typecheck.passed&&S.push({tool:`check`,reason:`Get full error details`,suggested_args:{detail:`errors`}}),x.deadSymbols&&x.deadSymbols.source>0&&S.push({tool:`dead_symbols`,reason:`See which exports are unused`,suggested_args:{root_path:_}}),o(`audit`,h,x,{durationMs:Date.now()-g,detail:y},S)}catch(e){return a(`audit`,{code:`ANALYSIS_FAILED`,category:`runtime`,retryable:!1,message:`Audit failed: ${e instanceof Error?e.message:String(e)}`},Date.now()-g)}}function p(e,t){let n=[];if(n.push(`## Audit Report — Score: ${e.score}/100\n`),e.structure&&n.push(`**Structure:** ${e.structure.files} files, ${e.structure.packages} packages, ${Object.keys(e.structure.languages).length} languages`),e.entryPoints){let t=Object.entries(e.entryPoints.types).map(([e,t])=>`${t} ${e}`).join(`, `);n.push(`**Entry Points:** ${e.entryPoints.total} (${t||`none`})`)}if(e.dependencies&&n.push(`**Dependencies:** ${e.dependencies.external} external, ${e.dependencies.internal} internal`),e.health&&n.push(`**Health:** ${e.health.score}/100 (${e.health.passed}✓ ${e.health.warned}⚠ ${e.health.failed}✗)`),e.deadSymbols&&n.push(`**Dead Symbols:** ${e.deadSymbols.source} in source (actionable), ${e.deadSymbols.docs} in docs`),e.typecheck){let t=e.typecheck.passed?`✓ passed`:`✗ ${e.typecheck.errorCount} errors`;n.push(`**Typecheck:** ${t}`)}if(e.lint){let t=e.lint.passed?`✓ passed`:`✗ ${e.lint.errorCount} errors`;n.push(`**Lint:** ${t}`)}if(e.recommendations.length>0){n.push(`
-### Recommendations
-`);for(let t of e.recommendations){let e=t.priority===`high`?`🔴`:t.priority===`medium`?`🟡`:`🟢`;n.push(`${e} **${t.area}:** ${t.message}`)}}if(t===`full`&&e.patterns&&e.patterns.length>0){n.push(`
-### Patterns Detected
-`),n.push(`| Pattern | Confidence | Count |`),n.push(`|---------|-----------|-------|`);for(let t of e.patterns)n.push(`| ${t.name} | ${t.confidence} | ${t.count} |`)}return n.join(`
-`)}export{f as audit};

package/packages/tools/dist/batch.d.ts

@@ -1,23 +0,0 @@
-//#region packages/tools/src/batch.d.ts
-interface BatchOperation {
-  /** Unique ID for this operation */
-  id: string;
-  /** Operation type */
-  type: string;
-  /** Arguments for the operation */
-  args: Record<string, unknown>;
-}
-interface BatchResult {
-  id: string;
-  status: 'success' | 'error';
-  result?: unknown;
-  error?: string;
-  durationMs: number;
-}
-interface BatchOptions {
-  /** Max concurrent operations (default: 4) */
-  concurrency?: number;
-}
-declare function batch(operations: BatchOperation[], executor: (op: BatchOperation) => Promise<unknown>, options?: BatchOptions): Promise<BatchResult[]>;
-//#endregion
-export { BatchOperation, BatchOptions, BatchResult, batch };

package/packages/tools/dist/batch.js

@@ -1 +0,0 @@
-async function e(e,t,n={}){let r=Math.max(1,n.concurrency??4),i=[],a=[...e];async function o(e){let n=Date.now();try{let r=await t(e);return{id:e.id,status:`success`,result:r,durationMs:Date.now()-n}}catch(t){return{id:e.id,status:`error`,error:t instanceof Error?t.message:String(t),durationMs:Date.now()-n}}}for(;a.length>0;){let e=a.splice(0,r),t=await Promise.allSettled(e.map(e=>o(e)));for(let n=0;n<t.length;n++){let r=t[n];if(r.status===`fulfilled`){i.push(r.value);continue}i.push({id:e[n]?.id??`unknown`,status:`error`,error:r.reason instanceof Error?r.reason.message:`Promise rejected`,durationMs:0})}}return i}export{e as batch};

package/packages/tools/dist/changelog.d.ts

@@ -1,36 +0,0 @@
-//#region packages/tools/src/changelog.d.ts
-/**
- * aikit_changelog — Generate a changelog from git history.
- */
-type ChangelogFormat = 'grouped' | 'chronological' | 'per-scope';
-interface ChangelogOptions {
-  from: string;
-  to?: string;
-  format?: ChangelogFormat;
-  includeBreaking?: boolean;
-  cwd?: string;
-}
-interface ChangelogEntry {
-  hash: string;
-  type: string;
-  scope: string;
-  subject: string;
-  body: string;
-  author: string;
-  date: string;
-  breaking: boolean;
-}
-interface ChangelogResult {
-  entries: ChangelogEntry[];
-  markdown: string;
-  stats: {
-    total: number;
-    breaking: number;
-    types: Record<string, number>;
-  };
-}
-declare function changelog(options: ChangelogOptions): ChangelogResult;
-/** Exported for testing */
-declare function formatChangelog(entries: ChangelogEntry[], format: ChangelogFormat, includeBreaking: boolean): string;
-//#endregion
-export { ChangelogEntry, ChangelogFormat, ChangelogOptions, ChangelogResult, changelog, formatChangelog };

package/packages/tools/dist/changelog.js

@@ -1,2 +0,0 @@
-import{execFileSync as e}from"node:child_process";const t=/^[a-zA-Z0-9_./\-~^@{}]+$/;function n(n){let{from:i,to:a=`HEAD`,format:o=`grouped`,includeBreaking:s=!0,cwd:c=process.cwd()}=n;if(!t.test(i))throw Error(`Invalid git ref: ${i}`);if(!t.test(a))throw Error(`Invalid git ref: ${a}`);let l;try{l=e(`git`,[`log`,`${i}..${a}`,`--format=%H%s%b%an%ai`],{cwd:c,encoding:`utf8`,maxBuffer:10*1024*1024,timeout:3e4})}catch{throw Error(`Git log failed. Ensure "${i}" and "${a}" are valid refs.`)}let u=l.split(``).map(e=>e.trim()).filter(Boolean).map(e=>{let[t=``,n=``,r=``,i=``,a=``]=e.split(``),o=n.match(/^(\w+)(?:\(([^)]*)\))?(!)?:\s*(.+)/);return{hash:t.slice(0,8),type:o?.[1]??`other`,scope:o?.[2]??``,subject:o?.[4]??n,body:r.trim(),author:i.trim(),date:a.trim().split(` `)[0],breaking:!!(o?.[3]||/BREAKING[\s-]CHANGE/i.test(r))}}),d={},f=0;for(let e of u)d[e.type]=(d[e.type]??0)+1,e.breaking&&f++;return{entries:u,markdown:r(u,o,s),stats:{total:u.length,breaking:f,types:d}}}function r(e,t,n){let r=[`# Changelog`,``];if(n){let t=e.filter(e=>e.breaking);if(t.length>0){r.push(`## Breaking Changes`,``);for(let e of t)r.push(`- ${e.subject} (${e.hash})`);r.push(``)}}if(t===`grouped`){let t={};for(let n of e)t[n.type]||(t[n.type]=[]),t[n.type].push(n);let n=[`feat`,`fix`,`refactor`,`perf`,`test`,`docs`,`chore`],i={feat:`Features`,fix:`Bug Fixes`,refactor:`Refactoring`,perf:`Performance`,test:`Tests`,docs:`Documentation`,chore:`Chores`,other:`Other`};for(let e of[...n,...Object.keys(t).filter(e=>!n.includes(e))])if(t[e]?.length){r.push(`## ${i[e]??e}`,``);for(let n of t[e]){let e=n.scope?`**${n.scope}:** `:``;r.push(`- ${e}${n.subject} (${n.hash})`)}r.push(``)}}else if(t===`chronological`)for(let t of e){let e=t.scope?`(${t.scope}) `:``;r.push(`- \`${t.date}\` ${t.type}: ${e}${t.subject} (${t.hash})`)}else{let t={};for(let n of e){let e=n.scope||`general`;t[e]||(t[e]=[]),t[e].push(n)}for(let[e,n]of Object.entries(t)){r.push(`## ${e}`,``);for(let e of n)r.push(`- ${e.type}: ${e.subject} (${e.hash})`);r.push(``)}}return r.join(`
-`)}export{n as changelog,r as formatChangelog};

package/packages/tools/dist/check.d.ts

@@ -1,48 +0,0 @@
-import { ParsedError } from "./parse-output.js";
-
-//#region packages/tools/src/check.d.ts
-interface CheckOptions {
-  /** Specific files to check (if empty, checks all) */
-  files?: string[];
-  /** Working directory */
-  cwd?: string;
-  /** Skip typecheck */
-  skipTypes?: boolean;
-  /** Skip lint */
-  skipLint?: boolean;
-  /** Detail level: summary (default, minimal), errors (parsed errors), full (includes raw) */
-  detail?: 'summary' | 'errors' | 'full';
-}
-interface CheckSummaryResult {
-  passed: boolean;
-  tsc: {
-    passed: boolean;
-    errorCount: number;
-    warningCount: number;
-    topErrors: string[];
-  };
-  biome: {
-    passed: boolean;
-    errorCount: number;
-    warningCount: number;
-    topErrors: string[];
-  };
-}
-interface CheckResult {
-  tsc: {
-    errors: ParsedError[];
-    passed: boolean;
-    raw?: string;
-  };
-  biome: {
-    errors: ParsedError[];
-    passed: boolean;
-    raw?: string;
-  };
-  passed: boolean;
-}
-declare function check(options?: CheckOptions): Promise<CheckResult>;
-/** Produce a minimal summary for LLM consumption (~300 tokens) */
-declare function summarizeCheckResult(result: CheckResult): CheckSummaryResult;
-//#endregion
-export { CheckOptions, CheckResult, CheckSummaryResult, check, summarizeCheckResult };

package/packages/tools/dist/check.js

@@ -1,2 +0,0 @@
-import{parseBiome as e,parseTsc as t}from"./parse-output.js";import{exec as n}from"node:child_process";import{readFile as r}from"node:fs/promises";import{join as i}from"node:path";import{promisify as a}from"node:util";const o=a(n);let s=0;function c(e){let t=e;return[t.stdout?.toString()??``,t.stderr?.toString()??``].filter(Boolean).join(`
-`).trim()||t.message||`Command failed`}async function l(e={}){if(s>=2)throw Error(`Too many concurrent check runs (max 2). Try again later.`);s++;try{return await u(e)}finally{s--}}async function u(n){let a=n.cwd??process.cwd(),s={errors:[],passed:!0,raw:``},l={errors:[],passed:!0,raw:``};if(!n.skipTypes)try{let e=i(a,`package.json`),t=!1;try{t=!!JSON.parse(await r(e,`utf-8`)).scripts?.typecheck}catch{}if(t&&!n.files?.length)await o(`npx turbo run typecheck`,{cwd:a,timeout:12e4});else{let e=[`--noEmit`];n.files?.length&&e.push(...n.files),await o(`npx tsc ${e.join(` `)}`,{cwd:a,timeout:12e4})}}catch(e){s.raw=c(e),s.errors=t(s.raw),s.passed=s.errors.length===0}if(!n.skipLint)try{let e=[`check`];n.files?.length&&e.push(...n.files),await o(`npx biome ${e.join(` `)}`,{cwd:a,timeout:12e4})}catch(t){l.raw=c(t),l.errors=e(l.raw),l.passed=l.errors.length===0}let u=n.detail??`errors`,d={tsc:s,biome:l,passed:s.passed&&l.passed};return u===`full`?d:{tsc:{errors:s.errors,passed:s.passed},biome:{errors:l.errors,passed:l.passed},passed:d.passed}}function d(e){let t=e.tsc.errors.filter(e=>e.severity===`error`),n=e.tsc.errors.filter(e=>e.severity===`warning`),r=e.biome.errors.filter(e=>e.severity===`error`),i=e.biome.errors.filter(e=>e.severity===`warning`);return{passed:e.passed,tsc:{passed:e.tsc.passed,errorCount:t.length,warningCount:n.length,topErrors:t.slice(0,3).map(e=>`${e.file}:${e.line} — ${e.message}`)},biome:{passed:e.biome.passed,errorCount:r.length,warningCount:i.length,topErrors:r.slice(0,3).map(e=>`${e.file}:${e.line} — ${e.message}`)}}}export{l as check,d as summarizeCheckResult};

package/packages/tools/dist/checkpoint.d.ts

@@ -1,19 +0,0 @@
-//#region packages/tools/src/checkpoint.d.ts
-interface Checkpoint {
-  id: string;
-  label: string;
-  createdAt: string;
-  data: Record<string, unknown>;
-  files?: string[];
-  notes?: string;
-}
-declare function checkpointSave(label: string, data: Record<string, unknown>, options?: {
-  files?: string[];
-  notes?: string;
-  cwd?: string;
-}): Checkpoint;
-declare function checkpointLoad(id: string, cwd?: string): Checkpoint | undefined;
-declare function checkpointList(cwd?: string): Checkpoint[];
-declare function checkpointLatest(cwd?: string): Checkpoint | undefined;
-//#endregion
-export { Checkpoint, checkpointLatest, checkpointList, checkpointLoad, checkpointSave };

package/packages/tools/dist/checkpoint.js

@@ -1 +0,0 @@
-import{resolve as e}from"node:path";import{existsSync as t,mkdirSync as n,readFileSync as r,readdirSync as i,renameSync as a,writeFileSync as o}from"node:fs";import{resolveStateDir as s}from"../../core/dist/index.js";function c(r){let i=e(s(r??process.cwd()),`checkpoints`);return t(i)||n(i,{recursive:!0}),i}function l(t,n,r){let i=t.toLowerCase().replace(/[^a-z0-9]+/g,`-`).replace(/^-|-$/g,``)||`checkpoint`,s={id:`${Date.now()}-${i}`,label:t,createdAt:new Date().toISOString(),data:n,files:r?.files,notes:r?.notes},l=e(c(r?.cwd),`${s.id}.json`),u=`${l}.tmp`;return o(u,`${JSON.stringify(s,null,2)}\n`,`utf-8`),a(u,l),s}function u(n,i){let a=c(i),o=e(a,`${n}.json`);if(o.startsWith(e(a))&&t(o))try{return JSON.parse(r(o,`utf-8`))}catch(e){if(e?.code===`ENOENT`)return;console.warn(`Corrupt state file ${o}: ${e instanceof Error?e.message:String(e)}`);return}}function d(t){let n=c(t);return i(n).filter(e=>e.endsWith(`.json`)).flatMap(t=>{let i=e(n,t);try{return[JSON.parse(r(i,`utf-8`))]}catch(e){return e?.code===`ENOENT`||console.warn(`Corrupt state file ${i}: ${e instanceof Error?e.message:String(e)}`),[]}}).sort((e,t)=>t.createdAt.localeCompare(e.createdAt))}function f(e){return d(e)[0]}export{f as checkpointLatest,d as checkpointList,u as checkpointLoad,l as checkpointSave};

package/packages/tools/dist/codemod.d.ts

@@ -1,39 +0,0 @@
-//#region packages/tools/src/codemod.d.ts
-interface CodemodRule {
-  /** Description of what this rule does */
-  description: string;
-  /** Regex pattern to match (string form, will be compiled) */
-  pattern: string;
-  /** Replacement string (supports $1, $2 capture groups) */
-  replacement: string;
-  /** Optional: only apply to files matching this glob */
-  fileFilter?: string;
-}
-interface CodemodOptions {
-  /** Root directory to apply codemod in */
-  rootPath: string;
-  /** Rules to apply */
-  rules: CodemodRule[];
-  /** File extensions to process */
-  extensions?: string[];
-  /** Exclude patterns */
-  exclude?: string[];
-  /** Dry run */
-  dryRun?: boolean;
-}
-interface CodemodChange {
-  rule: string;
-  path: string;
-  line: number;
-  before: string;
-  after: string;
-}
-interface CodemodResult {
-  changes: CodemodChange[];
-  rulesApplied: number;
-  filesModified: number;
-  dryRun: boolean;
-}
-declare function codemod(options: CodemodOptions): Promise<CodemodResult>;
-//#endregion
-export { CodemodChange, CodemodOptions, CodemodResult, CodemodRule, codemod };

package/packages/tools/dist/codemod.js

@@ -1,2 +0,0 @@
-import{DEFAULT_TOOL_EXTENSIONS as e,matchesGlobPattern as t,walkFiles as n}from"./file-walk.js";import{createRestorePoint as r}from"./restore-points.js";import{readFile as i,writeFile as a}from"node:fs/promises";import{relative as o}from"node:path";function s(e){return e.replace(/\\/g,`/`)}async function c(c){let{rootPath:l,rules:u,extensions:d=e,exclude:f=[],dryRun:p=!1}=c,m=u.map(e=>({...e,regex:new RegExp(e.pattern,`g`)})),h=await n(l,d,f),g=[],_=new Set,v=0,y=[];for(let e of h){let n=s(o(l,e)),r=await i(e,`utf-8`),c=r.split(/\r?\n/),u=!1;for(let[e,r]of m.entries())if(!(r.fileFilter&&!t(n,r.fileFilter)))for(let t=0;t<c.length;t++){let i=c[t];r.regex.lastIndex=0;let a=i.replace(r.regex,r.replacement);i!==a&&(c[t]=a,u=!0,_.add(e),g.push({rule:r.description,path:n,line:t+1,before:i,after:a}))}u&&(v+=1,p||(y.push({path:e,content:r}),await a(e,c.join(`
-`),`utf-8`)))}return!p&&y.length>0&&r(`codemod`,y,`codemod: ${u.length} rules, ${v} files`),{changes:g,rulesApplied:_.size,filesModified:v,dryRun:p}}export{c as codemod};

package/packages/tools/dist/compact.d.ts

@@ -1,47 +0,0 @@
-import { FileCache } from "./file-cache.js";
-import { IEmbedder } from "../../embeddings/dist/index.js";
-
-//#region packages/tools/src/compact.d.ts
-interface CompactOptions {
-  /** The text to compress (at least one of text/path required) */
-  text?: string;
-  /** File path to read server-side — avoids read_file round-trip (at least one of text/path required) */
-  path?: string;
-  /** The focus query — what are we trying to understand? */
-  query: string;
-  /** Target output size in characters (default: 3000) */
-  maxChars?: number;
-  /** Token budget — when set, overrides maxChars (approx 4 chars per token) */
-  tokenBudget?: number;
-  /** Minimum similarity score to include a segment (0-1, default: 0.3) */
-  minScore?: number;
-  /** Segmentation strategy (default: 'paragraph') */
-  segmentation?: 'paragraph' | 'sentence' | 'line';
-  /** Optional file cache — use cached content instead of raw readFile */
-  cache?: FileCache;
-  /**
-   * Content delivery mode:
-   * - 'full' (default): Return compressed text as normal
-   * - 'delta': Return only changes since last read (for re-reads of same file)
-   */
-  mode?: 'full' | 'delta';
-}
-interface CompactResult {
-  /** The compressed text */
-  text: string;
-  /** Original size in chars */
-  originalChars: number;
-  /** Compressed size in chars */
-  compressedChars: number;
-  /** Compression ratio (0-1, lower = more compressed) */
-  ratio: number;
-  /** Number of segments kept / total */
-  segmentsKept: number;
-  segmentsTotal: number;
-}
-/**
- * Compress text by extracting segments most relevant to a query.
- */
-declare function compact(embedder: IEmbedder, options: CompactOptions): Promise<CompactResult>;
-//#endregion
-export { CompactOptions, CompactResult, compact };

package/packages/tools/dist/compact.js

@@ -1,3 +0,0 @@
-import{bookendReorder as e,cosineSimilarity as t,segment as n}from"./text-utils.js";import{getDelta as r}from"./compression/delta-cache.js";import{scoreLines as i}from"./compression/scoring.js";import{readFile as a,stat as o}from"node:fs/promises";async function s(s,c){let{query:l,maxChars:u=3e3,minScore:d=.3,segmentation:f=`paragraph`}=c,p=c.tokenBudget?c.tokenBudget*4:u,m;if(c.text)m=c.text;else if(c.path){let e;try{e=await o(c.path)}catch(e){let t=e.code;throw t===`ENOENT`?Error(`File not found: ${c.path}. Check the path and try again.`):t===`EACCES`||t===`EPERM`?Error(`Permission denied reading ${c.path}. The file exists but is not accessible.`):e}if(e.isDirectory())throw Error(`Path is a directory: ${c.path}. compact requires a file path, not a directory. Use analyze_structure or find to explore directories.`);if(e.size>1e7)throw Error(`File too large (${(e.size/1e6).toFixed(1)}MB). compact supports files up to 10MB. Consider splitting or using search instead.`);m=c.cache?(await c.cache.get(c.path)).content:await a(c.path,`utf-8`)}else throw Error(`Either "text" or "path" must be provided`);if(c.mode===`delta`&&c.path){let e=r(c.path,m);if(e.isDelta)return{text:e.text,originalChars:m.length,compressedChars:e.text.length,ratio:e.text.length/m.length,segmentsKept:1,segmentsTotal:1}}if(m.length<=p)return{text:m,originalChars:m.length,compressedChars:m.length,ratio:1,segmentsKept:1,segmentsTotal:1};let h=n(m,f);if(h.length===0)return{text:``,originalChars:m.length,compressedChars:0,ratio:0,segmentsKept:0,segmentsTotal:0};let g=await s.embed(l),_=i(h),v=[];for(let e=0;e<h.length;e++){let n=.85*t(g,await s.embed(h[e]))+.15*(_[e]??0);v.push({text:h[e],score:n,index:e})}let y=v.filter(e=>e.score>=d).sort((e,t)=>t.score-e.score),b=[],x=0;for(let e of y){if(x+e.text.length>p){x===0&&(b.push({...e,text:e.text.slice(0,p)}),x=p);break}b.push(e),x+=e.text.length+2}let S=e(b.sort((e,t)=>t.score-e.score)).map(e=>e.text).join(`
-
-`);return{text:S,originalChars:m.length,compressedChars:S.length,ratio:S.length/m.length,segmentsKept:b.length,segmentsTotal:h.length}}export{s as compact};

package/packages/tools/dist/compress-output.d.ts

@@ -1,38 +0,0 @@
-import { CompressionMode, CompressionResult } from "./compression/types.js";
-import { detectOutputTool } from "./compression/engine.js";
-
-//#region packages/tools/src/compress-output.d.ts
-interface CompressOutputOptions {
-  /** Raw terminal/shell output text */
-  text: string;
-  /** Override detected tool (e.g., 'git', 'npm', 'tsc') */
-  tool?: string;
-  /** Compression mode: structural (default), heuristic, aggressive */
-  mode?: CompressionMode;
-  /** Maximum output characters (default: 4000) */
-  maxChars?: number;
-  /** Maximum output tokens (alternative to maxChars, uses 4 chars/token) */
-  tokenBudget?: number;
-}
-/**
- * Compress terminal/shell output using intelligent rule-based compression.
- *
- * Automatically detects the tool that produced the output (git, npm, tsc,
- * vitest, docker, kubectl, ESLint, etc.) and applies tool-specific
- * compression strategies that preserve critical information while reducing
- * token count.
- *
- * @example
- * ```ts
- * const result = compressTerminalOutput({
- *   text: rawGitDiff,
- *   maxChars: 3000,
- * });
- * // result.text contains compressed output
- * // result.rule tells which compression rule was applied
- * // result._meta.truncated tells if output was further truncated
- * ```
- */
-declare function compressTerminalOutput(options: CompressOutputOptions): CompressionResult;
-//#endregion
-export { CompressOutputOptions, type CompressionMode, type CompressionResult, compressTerminalOutput, detectOutputTool };

package/packages/tools/dist/compress-output.js

@@ -1 +0,0 @@
-import{compressOutput as e,detectOutputTool as t}from"./compression/engine.js";import"./compression/rules/index.js";function n(t){let{text:n,tool:r,mode:i=`structural`,maxChars:a,tokenBudget:o}=t;return e(n,{mode:i,maxChars:o?o*4:a??4e3,tool:r})}export{n as compressTerminalOutput,t as detectOutputTool};

package/packages/tools/dist/compression/delta-cache.d.ts

@@ -1,29 +0,0 @@
-//#region packages/tools/src/compression/delta-cache.d.ts
-interface DeltaCacheEntry {
-  hash: string;
-  text: string;
-  timestamp: number;
-}
-interface DeltaResult {
-  /** The delta text (diff or full text if no prior version) */
-  text: string;
-  /** Whether this is a delta (true) or full text (false) */
-  isDelta: boolean;
-  /** Content hash of current version */
-  hash: string;
-}
-/**
- * Get delta for a given key (typically file path).
- * Returns unified diff if prior version cached, or full text otherwise.
- */
-declare function getDelta(key: string, currentText: string): DeltaResult;
-/**
- * Clear the delta cache (useful for testing).
- */
-declare function clearDeltaCache(): void;
-/**
- * Check if a key has a cached version.
- */
-declare function hasCachedVersion(key: string): boolean;
-//#endregion
-export { DeltaCacheEntry, DeltaResult, clearDeltaCache, getDelta, hasCachedVersion };

package/packages/tools/dist/compression/delta-cache.js

@@ -1 +0,0 @@
-import{createHash as e}from"node:crypto";import{createTwoFilesPatch as t}from"diff";import{LRUCache as n}from"lru-cache";const r=new n({max:200,ttl:1e3*60*30});function i(t){return e(`sha256`).update(t).digest(`hex`).slice(0,16)}function a(e,n){let a=i(n),o=r.get(e);if(r.set(e,{hash:a,text:n,timestamp:Date.now()}),!o||o.hash===a)return{text:o?.hash===a?`[No changes since last read]`:n,isDelta:o?.hash===a,hash:a};let s=t(e,e,o.text,n,`previous`,`current`,{context:3});return s.length>=n.length*.8?{text:n,isDelta:!1,hash:a}:{text:s,isDelta:!0,hash:a}}function o(){r.clear()}function s(e){return r.has(e)}export{o as clearDeltaCache,a as getDelta,s as hasCachedVersion};

package/packages/tools/dist/compression/engine.d.ts

@@ -1,34 +0,0 @@
-import { CompressionContext, CompressionMode, CompressionResult, CompressionRule } from "./types.js";
-
-//#region packages/tools/src/compression/engine.d.ts
-/**
- * Register a compression rule. Rules are auto-sorted by priority (highest first).
- */
-declare function registerRule(rule: CompressionRule): void;
-/**
- * Register multiple compression rules at once.
- */
-declare function registerRules(newRules: CompressionRule[]): void;
-/**
- * Get all registered rules (for testing/inspection).
- */
-declare function getRegisteredRules(): readonly CompressionRule[];
-/**
- * Detect the tool that produced the output.
- * Uses heuristic pattern matching on the raw text.
- */
-declare function detectOutputTool(text: string): string;
-/**
- * Core compression pipeline.
- * 1. Strip ANSI codes
- * 2. Detect tool
- * 3. Find matching rule (priority order)
- * 4. Apply rule or fall back to truncation
- */
-declare function compressOutput(rawText: string, options?: {
-  mode?: CompressionMode;
-  maxChars?: number;
-  tool?: string;
-}): CompressionResult;
-//#endregion
-export { type CompressionContext, type CompressionMode, type CompressionResult, type CompressionRule, compressOutput, detectOutputTool, getRegisteredRules, registerRule, registerRules };

package/packages/tools/dist/compression/engine.js

@@ -1,4 +0,0 @@
-import{stripAnsi as e}from"../parse-output.js";import{estimateTokens as t}from"../text-utils.js";const n=[];function r(e){n.push(e),n.sort((e,t)=>t.priority-e.priority)}function i(e){for(let t of e)r(t)}function a(){return n}function o(e){return/^(diff --git|commit [0-9a-f]{7,40}|On branch |Your branch )/m.test(e)?`git`:/^\s*[MADRCU?!]{1,2}\s+\S/m.test(e)&&/^##\s/m.test(e)?`git-status`:/^(npm (warn|ERR!|notice)|added \d+ packages?|up to date)/m.test(e)?`npm`:/^(Packages|Progress):/m.test(e)||/pnpm/.test(e)?`pnpm`:/✓|✗|PASS|FAIL|Tests?\s+\d+\s+(passed|failed)/m.test(e)||/^(PASS|FAIL)\s+\S/m.test(e)?`test-runner`:/^(error TS\d+|warning TS\d+|\S+\.tsx?[(:]\d+)/m.test(e)?`tsc`:/^\S+\.\w+:\d+:\d+\s+(error|warning|info)/m.test(e)||/Found \d+ (error|warning)/m.test(e)?`lint`:/^(CONTAINER ID|IMAGE|REPOSITORY|Step \d+\/\d+|--->)/m.test(e)||/docker|Dockerfile/i.test(e)?`docker`:/^(NAME\s+READY|NAMESPACE\s|kubectl)/m.test(e)?`kubectl`:`unknown`}function s(r,i={}){let{mode:a=`structural`,maxChars:s=4e3}=i,c=e(r),l=i.tool??o(c),u=c.length;if(u<=s)return{text:c,originalChars:u,compressedChars:c.length,ratio:1,rule:`passthrough`,tool:l,_meta:{truncated:!1,mode:a}};let d={text:c,tool:l,mode:a,maxChars:s,originalChars:u};for(let e of n)if(e.match(d)){let n=e.compress(d),r=n.length,i=r>s?`${n.slice(0,s-50)}\n... [truncated ${r-s+50} chars, ~${t(n.slice(s-50))} tokens]`:n;return{text:i,originalChars:u,compressedChars:i.length,ratio:i.length/u,rule:e.name,tool:l,_meta:{truncated:r>s,mode:a}}}let f=Math.floor(s*.6),p=s-f-60,m=c.split(`
-`),h=``,g=0;for(let e of m){if(h.length+e.length+1>f)break;h+=`${h?`
-`:``}${e}`,g++}let _=``,v=0;for(let e=m.length-1;e>=g&&!(_.length+m[e].length+1>p);e--)_=`${m[e]}${_?`
-`:``}${_}`,v++;let y=`\n... [${m.length-g-v} lines omitted (${Math.max(0,u-h.length-_.length)} chars, ~${t(c.slice(h.length,Math.max(h.length,c.length-_.length)))} tokens)] ...\n`,b=`${h}${y}${_}`;return{text:b,originalChars:u,compressedChars:b.length,ratio:b.length/u,rule:`fallback-truncation`,tool:l,_meta:{truncated:!0,mode:a}}}export{s as compressOutput,o as detectOutputTool,a as getRegisteredRules,r as registerRule,i as registerRules};

package/packages/tools/dist/compression/litm.d.ts

@@ -1,20 +0,0 @@
-//#region packages/tools/src/compression/litm.d.ts
-/**
- * LITM-aware block positioning for multi-source digest.
- * Liu et al. TACL 2024: LLMs attend more to start and end positions.
- * Re-orders source blocks so highest-relevance sources appear at edges.
- */
-interface ScoredBlock {
-  id: string;
-  text: string;
-  /** Maximum segment score for this source block */
-  maxScore: number;
-}
-/**
- * Reorder source blocks using bookend (U-curve) positioning.
- * Highest-scoring blocks placed at start and end positions.
- * Input order is preserved for blocks with equal scores.
- */
-declare function reorderBlocksLITM(blocks: ScoredBlock[]): ScoredBlock[];
-//#endregion
-export { ScoredBlock, reorderBlocksLITM };

package/packages/tools/dist/compression/litm.js

@@ -1 +0,0 @@
-function e(e){if(e.length<=2)return e;let t=[...e].sort((e,t)=>t.maxScore-e.maxScore),n=Array(t.length),r=0,i=t.length-1;for(let e=0;e<t.length;e++)e%2==0?n[r++]=t[e]:n[i--]=t[e];return n}export{e as reorderBlocksLITM};

package/packages/tools/dist/compression/mmr.d.ts

@@ -1,24 +0,0 @@
-//#region packages/tools/src/compression/mmr.d.ts
-/**
- * MMR (Maximal Marginal Relevance) deduplication for digest segments.
- * Prevents near-identical segments from consuming budget.
- * Uses bigram Jaccard similarity for fast structural comparison.
- */
-interface MMRCandidate {
-  index: number;
-  text: string;
-  /** Query relevance score (0-1) */
-  relevance: number;
-}
-/**
- * Select segments using MMR to balance relevance and diversity.
- *
- * @param candidates - Segments with their relevance scores
- * @param lambda - Trade-off: 1.0 = pure relevance, 0.0 = pure diversity (default: 0.7)
- * @param maxItems - Maximum items to select (default: all)
- * @param safetyThreshold - Segments above this relevance are always kept (default: 0.8)
- * @returns Selected candidates in MMR order
- */
-declare function mmrSelect(candidates: MMRCandidate[], lambda?: number, maxItems?: number, safetyThreshold?: number): MMRCandidate[];
-//#endregion
-export { MMRCandidate, mmrSelect };

package/packages/tools/dist/compression/mmr.js

@@ -1 +0,0 @@
-function e(e){let t=new Set,n=e.toLowerCase().replace(/\s+/g,` `);for(let e=0;e<n.length-1;e++)t.add(n.slice(e,e+2));return t}function t(e,t){if(e.size===0&&t.size===0)return 1;let n=0;for(let r of e)t.has(r)&&n++;let r=e.size+t.size-n;return r===0?0:n/r}function n(n,r=.7,i,a=.8){if(n.length===0)return[];let o=i??n.length,s=[],c=[],l=new Set(n.map((e,t)=>t)),u=n.map(t=>e(t.text));for(;s.length<o&&l.size>0;){let e=-1,i=-1/0;for(let o of l){let l=n[o];if(l.relevance>=a&&s.length===0){e=o;break}let d=0;for(let e of c){let n=t(u[o],e);n>d&&(d=n)}let f=r*l.relevance-(1-r)*d;f>i&&(i=f,e=o)}if(e===-1)break;s.push(n[e]),c.push(u[e]),l.delete(e)}return s}export{n as mmrSelect};

package/packages/tools/dist/compression/rules/docker.d.ts

@@ -1,11 +0,0 @@
-import { CompressionRule } from "../types.js";
-
-//#region packages/tools/src/compression/rules/docker.d.ts
-/**
- * Compression rule for Docker build/run output.
- * Preserves: build errors, final image info, layer cache hits.
- * Collapses: download progress, intermediate steps.
- */
-declare const dockerRule: CompressionRule;
-//#endregion
-export { dockerRule };

package/packages/tools/dist/compression/rules/docker.js

@@ -1,3 +0,0 @@
-const e={name:`docker`,toolPatterns:[`docker`],priority:8,match(e){return e.tool===`docker`},compress(e){let t=e.text.split(`
-`),n=[],r=0,i=0;for(let e of t){if(e.match(/^(ERROR|error|Error|WARNING|SECURITY)/i)||e.includes(`failed`)){n.push(e);continue}if(e.match(/^Step \d+\/\d+\s*:/)){n.push(e);continue}if(e.match(/^\s*(FROM|RUN|COPY|ADD|WORKDIR|ENV|EXPOSE|CMD|ENTRYPOINT)\s/i)){n.push(e);continue}if(e.includes(`CACHED`)||e.includes(`Using cache`)){r++;continue}if(e.match(/^[a-f0-9]+:\s*(Pull|Download|Extract|Waiting|Verifying)/)){i++;continue}if(e.match(/^(Successfully|sha256:|REPOSITORY|IMAGE ID|CONTAINER ID)/)){n.push(e);continue}if(e.match(/^\S{12}\s+\S+/)&&!e.match(/^[a-f0-9]+:/)){n.push(e);continue}e.match(/^#\d+\s/)&&n.push(e)}return r>0&&n.push(`[${r} cached layers]`),i>0&&n.push(`[${i} download/extract operations]`),n.join(`
-`)}};export{e as dockerRule};

package/packages/tools/dist/compression/rules/generic.d.ts

@@ -1,11 +0,0 @@
-import { CompressionRule } from "../types.js";
-
-//#region packages/tools/src/compression/rules/generic.d.ts
-/**
- * Generic compression rule — lowest priority fallback.
- * Handles: dedup repeated lines, collapse blank lines, smart truncation.
- * Applied when no specific tool rule matches.
- */
-declare const genericRule: CompressionRule;
-//#endregion
-export { genericRule };

package/packages/tools/dist/compression/rules/generic.js

@@ -1,3 +0,0 @@
-const e={name:`generic`,toolPatterns:[/.*/],priority:0,match(e){return e.tool===`unknown`||!e.tool},compress(e){let t=e.text.split(`
-`),n=[],r=``,i=0,a=0;for(let e of t){let t=e.trim();if(t===``){a++,a<=1&&n.push(``);continue}if(a=0,t===r.trim()){i++;continue}i>0&&(n.push(`  [repeated ${i} more times]`),i=0),r=e,n.push(e)}return i>0&&n.push(`  [repeated ${i} more times]`),n.join(`
-`)}};export{e as genericRule};

package/packages/tools/dist/compression/rules/git.d.ts

@@ -1,11 +0,0 @@
-import { CompressionRule } from "../types.js";
-
-//#region packages/tools/src/compression/rules/git.d.ts
-/**
- * Compression rule for git diff and git log output.
- * Preserves: file list, +/- stats, error messages.
- * Collapses: hunk bodies, repeated context lines.
- */
-declare const gitRule: CompressionRule;
-//#endregion
-export { gitRule };

package/packages/tools/dist/compression/rules/git.js

@@ -1,3 +0,0 @@
-const e={name:`git`,toolPatterns:[`git`,`git-status`],priority:10,match(e){return e.tool===`git`||e.tool===`git-status`},compress(e){let t=e.text.split(`
-`),n=[],r=!1,i=0,a=0,o=``;for(let s of t){if(s.startsWith(`diff --git`)||s.startsWith(`---`)||s.startsWith(`+++`)){r&&(i>0||a>0)&&n.push(`  [${i}+ ${a}- lines in ${o}]`),r=!1,i=0,a=0,n.push(s),s.startsWith(`diff --git`)&&(o=s.replace(/^diff --git a\/\S+ b\//,``));continue}if(s.startsWith(`@@`)){r&&(i>0||a>0)&&n.push(`  [${i}+ ${a}- lines]`),r=!0,i=0,a=0,n.push(s);continue}if(e.tool===`git-status`){n.push(s);continue}if(r){s.startsWith(`+`)?i++:s.startsWith(`-`)&&a++;continue}if(s.startsWith(`commit `)||s.startsWith(`Author:`)||s.startsWith(`Date:`)||s.startsWith(`On branch`)||s.match(/^\s*\d+ file/)||s.match(/insertion|deletion/)){n.push(s);continue}if(s.startsWith(`error:`)||s.startsWith(`fatal:`)||s.startsWith(`warning:`)){n.push(s);continue}/^\s{4}\S/.test(s)&&n.push(s)}return r&&(i>0||a>0)&&n.push(`  [${i}+ ${a}- lines in ${o}]`),n.join(`
-`)}};export{e as gitRule};