@vpxa/aikit 0.1.1

package/packages/chunker/src/queries/javascript/symbols.scm

@@ -0,0 +1,52 @@
+; JavaScript symbol extraction queries
+; Same as TypeScript but without interface, type alias, and enum nodes.
+; JS uses `identifier` for class names (not `type_identifier`).
+
+; === Exported declarations ===
+
+; export function foo() {}
+(export_statement
+  (function_declaration
+    name: (identifier) @name) @node) @exported
+
+; export class Foo {}
+(export_statement
+  (class_declaration
+    name: (identifier) @name) @node) @exported
+
+; export const FOO = ...
+(export_statement
+  (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name)) @node) @exported
+
+; export default class Foo {}
+(export_statement
+  "default"
+  (class_declaration
+    name: (identifier) @name) @node) @exported
+
+; === Non-exported declarations ===
+
+; function foo() {}
+(function_declaration
+  name: (identifier) @name) @node
+
+; class Foo {}
+(class_declaration
+  name: (identifier) @name) @node
+
+; const foo = ...
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @name)) @node
+
+; === Class members ===
+
+; class methods: foo() {} / async foo() {} / static foo() {}
+(method_definition
+  name: (property_identifier) @name) @node
+
+; class properties: foo = value
+(field_definition
+  property: (property_identifier) @name) @node

package/packages/chunker/src/queries/python/calls.scm

@@ -0,0 +1,11 @@
+; Python call extraction queries
+; Captures: @node (call expression), @callee (function/method name)
+
+; foo(args) — direct function call
+(call
+  function: (identifier) @callee) @node
+
+; obj.method(args) — attribute/method call
+(call
+  function: (attribute
+    attribute: (identifier) @callee)) @node

package/packages/chunker/src/queries/python/entry-points.scm

@@ -0,0 +1,21 @@
+; Python entry-point detection queries
+; Captures: @node (entry point), @name (identifier)
+
+; if __name__ == "__main__":
+(if_statement
+  condition: (comparison_operator
+    (identifier) @name
+    (#eq? @name "__name__"))) @node
+
+; Flask/FastAPI/Sanic app creation
+; app = Flask(__name__) / app = FastAPI()
+(assignment
+  left: (identifier) @name
+  right: (call
+    function: (identifier) @_cls
+    (#match? @_cls "^(Flask|FastAPI|Sanic|Quart)$"))) @node
+
+; Django urlpatterns
+(assignment
+  left: (identifier) @name
+  (#eq? @name "urlpatterns")) @node

package/packages/chunker/src/queries/python/imports.scm

@@ -0,0 +1,14 @@
+; Python import extraction queries
+; Captures: @node (import statement), @source (module path)
+
+; import foo / import foo.bar
+(import_statement
+  name: (dotted_name) @source) @node
+
+; from foo import bar
+(import_from_statement
+  module_name: (dotted_name) @source) @node
+
+; from . import foo (relative import)
+(import_from_statement
+  module_name: (relative_import) @source) @node

package/packages/chunker/src/queries/python/patterns.scm

@@ -0,0 +1,25 @@
+; Python pattern detection queries
+; Captures: @node (pattern site), @name (identifier)
+
+; Singleton: __new__ override
+(function_definition
+  name: (identifier) @name
+  (#eq? @name "__new__")) @node
+
+; Decorator pattern (direct decorator call)
+(decorated_definition
+  (decorator
+    (call
+      function: (identifier) @name))) @node
+
+; Decorator pattern (attribute decorator like @app.route)
+(decorated_definition
+  (decorator
+    (call
+      function: (attribute
+        attribute: (identifier) @name)))) @node
+
+; Context manager class (__enter__)
+(function_definition
+  name: (identifier) @name
+  (#eq? @name "__enter__")) @node

package/packages/chunker/src/queries/python/symbols.scm

@@ -0,0 +1,17 @@
+; Python symbol extraction queries
+; Captures: @node (declaration), @name (identifier)
+; No explicit export in Python — extractor uses name prefix (_ = private)
+
+; Function definition
+(function_definition
+  name: (identifier) @name) @node
+
+; Class definition
+(class_definition
+  name: (identifier) @name) @node
+
+; Module-level assignment (constants/variables)
+(module
+  (expression_statement
+    (assignment
+      left: (identifier) @name)) @node)

package/packages/chunker/src/queries/rust/calls.scm

@@ -0,0 +1,20 @@
+; Rust call extraction queries
+; Captures: @node (call), @callee (function/method name)
+
+; foo(args) — direct function call
+(call_expression
+  function: (identifier) @callee) @node
+
+; path::to::func(args) — qualified call
+(call_expression
+  function: (scoped_identifier
+    name: (identifier) @callee)) @node
+
+; obj.method(args) — method call
+(call_expression
+  function: (field_expression
+    field: (field_identifier) @callee)) @node
+
+; println!("...") — macro invocation
+(macro_invocation
+  macro: (identifier) @callee) @node

package/packages/chunker/src/queries/rust/entry-points.scm

@@ -0,0 +1,7 @@
+; Rust entry-point detection queries
+; Captures: @node (declaration), @name (function name)
+
+; fn main()
+(function_item
+  name: (identifier) @name
+  (#eq? @name "main")) @node

package/packages/chunker/src/queries/rust/imports.scm

@@ -0,0 +1,26 @@
+; Rust import extraction queries
+; Captures: @node (use declaration), @source (path)
+
+; use std::collections::HashMap
+(use_declaration
+  argument: (scoped_identifier) @source) @node
+
+; use foo::bar::{A, B}
+(use_declaration
+  argument: (scoped_use_list) @source) @node
+
+; use foo::*
+(use_declaration
+  argument: (use_wildcard) @source) @node
+
+; use foo as bar
+(use_declaration
+  argument: (use_as_clause) @source) @node
+
+; use foo
+(use_declaration
+  argument: (identifier) @source) @node
+
+; extern crate foo
+(extern_crate_declaration
+  name: (identifier) @source) @node

package/packages/chunker/src/queries/rust/patterns.scm

@@ -0,0 +1,18 @@
+; Rust pattern detection queries
+; Captures: @node (pattern site), @name (identifier)
+
+; impl Trait for Type (trait implementation)
+(impl_item
+  trait: (type_identifier) @name) @node
+
+; Derive macro attribute
+(attribute_item
+  (attribute
+    (identifier) @name
+    (#eq? @name "derive"))) @node
+
+; Test attribute
+(attribute_item
+  (attribute
+    (identifier) @name
+    (#eq? @name "test"))) @node

package/packages/chunker/src/queries/rust/symbols.scm

@@ -0,0 +1,73 @@
+; Rust symbol extraction queries
+; Captures: @node (declaration), @name (identifier), @exported (visibility_modifier)
+
+; === Exported (pub) declarations ===
+
+; pub fn foo() {}
+(function_item
+  (visibility_modifier) @exported
+  name: (identifier) @name) @node
+
+; pub struct Foo {}
+(struct_item
+  (visibility_modifier) @exported
+  name: (type_identifier) @name) @node
+
+; pub enum Color {}
+(enum_item
+  (visibility_modifier) @exported
+  name: (type_identifier) @name) @node
+
+; pub trait MyTrait {}
+(trait_item
+  (visibility_modifier) @exported
+  name: (type_identifier) @name) @node
+
+; pub const FOO: i32 = 42
+(const_item
+  (visibility_modifier) @exported
+  name: (identifier) @name) @node
+
+; pub static FOO: i32 = 42
+(static_item
+  (visibility_modifier) @exported
+  name: (identifier) @name) @node
+
+; pub type Alias = ...
+(type_item
+  (visibility_modifier) @exported
+  name: (type_identifier) @name) @node
+
+; === Non-exported declarations ===
+
+; fn foo() {}
+(function_item
+  name: (identifier) @name) @node
+
+; struct Foo {}
+(struct_item
+  name: (type_identifier) @name) @node
+
+; enum Color {}
+(enum_item
+  name: (type_identifier) @name) @node
+
+; trait MyTrait {}
+(trait_item
+  name: (type_identifier) @name) @node
+
+; impl Foo {}
+(impl_item
+  type: (type_identifier) @name) @node
+
+; const FOO: i32 = 42
+(const_item
+  name: (identifier) @name) @node
+
+; static FOO: i32 = 42
+(static_item
+  name: (identifier) @name) @node
+
+; type Alias = ...
+(type_item
+  name: (type_identifier) @name) @node

package/packages/chunker/src/queries/typescript/calls.scm

@@ -0,0 +1,21 @@
+; TypeScript call extraction queries
+; Captures: @node (full call/new expression), @callee (function/method name)
+
+; === Direct function calls ===
+
+; foo(args)
+(call_expression
+  function: (identifier) @callee) @node
+
+; === Method calls ===
+
+; obj.method(args)
+(call_expression
+  function: (member_expression
+    property: (property_identifier) @callee)) @node
+
+; === Constructor calls ===
+
+; new Foo(args)
+(new_expression
+  constructor: (identifier) @callee) @node

package/packages/chunker/src/queries/typescript/entry-points.scm

@@ -0,0 +1,48 @@
+; TypeScript entry-point detection queries
+; Captures: @node (full declaration), @name (entry point function/class name)
+
+; === Lambda/serverless handler exports ===
+
+; export const handler = ...
+; export const main = ...
+(export_statement
+  (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      (#match? @name "^(handler|main|lambdaHandler)$")))) @node
+
+; === Exported handler functions ===
+
+; export function handler() {}
+; export async function handler() {}
+(export_statement
+  (function_declaration
+    name: (identifier) @name
+    (#match? @name "^(handler|main|lambdaHandler)$"))) @node
+
+; === CDK Construct / Stack classes ===
+
+; export class MyStack extends Stack {}
+(export_statement
+  (class_declaration
+    name: (type_identifier) @name
+    (class_heritage
+      (extends_clause
+        value: (identifier) @_parent
+        (#match? @_parent "^(Construct|Stack|NestedStack|Stage)$"))))) @node
+
+; === Express/Hono/Fastify app exports ===
+
+; export const app = express() / new Hono() / new App()
+(export_statement
+  (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      (#match? @name "^(app|server|router)$")))) @node
+
+; === Default export of app/handler ===
+
+; export default app
+(export_statement
+  "default"
+  (identifier) @name) @node

package/packages/chunker/src/queries/typescript/imports.scm

@@ -0,0 +1,35 @@
+; TypeScript import extraction queries
+; Captures: @node (full import statement), @source (module path string)
+
+; === ES module imports ===
+
+; import { foo } from './module'
+; import type { IFoo } from './types'
+; import Def from 'pkg'
+; import * as ns from 'pkg'
+(import_statement
+  source: (string
+    (string_fragment) @source)) @node
+
+; === CommonJS require ===
+
+; const x = require('./mod')
+; const { a, b } = require('./mod')
+(lexical_declaration
+  (variable_declarator
+    value: (call_expression
+      function: (identifier) @_fn
+      arguments: (arguments
+        (string
+          (string_fragment) @source))))
+  (#eq? @_fn "require")) @node
+
+; === Dynamic import ===
+
+; const x = await import('./dynamic')
+; import('./dynamic').then(...)
+(call_expression
+  function: (import)
+  arguments: (arguments
+    (string
+      (string_fragment) @source))) @node

package/packages/chunker/src/queries/typescript/patterns.scm

@@ -0,0 +1,47 @@
+; TypeScript pattern detection queries
+; Captures: @node (pattern site), @name (identifier or function name)
+
+; === Singleton: private constructor or cached instances ===
+
+; class Foo { private constructor() {} }
+(class_declaration
+  name: (type_identifier) @name
+  body: (class_body
+    (method_definition
+      (accessibility_modifier) @_access
+      name: (property_identifier) @_ctor)
+    (#eq? @_access "private")
+    (#eq? @_ctor "constructor"))) @node
+
+; === Factory: export function create*() ===
+
+(export_statement
+  (function_declaration
+    name: (identifier) @name
+    (#match? @name "^create[A-Z]"))) @node
+
+; === Dependency Injection markers ===
+
+; container.register(...) / container.bind(...)
+(call_expression
+  function: (member_expression
+    object: (identifier) @_obj
+    property: (property_identifier) @_method)
+  (#eq? @_obj "container")
+  (#match? @_method "^(register|bind)$")) @node
+
+; === Decorator patterns ===
+; @Injectable() / @Component() etc.
+(decorator
+  (call_expression
+    function: (identifier) @name
+    (#match? @name "^(Injectable|Component|Service|Controller|Module)$"))) @node
+
+; === Cached instance: new Map() / new WeakMap() ===
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @name
+    value: (new_expression
+      constructor: (identifier) @_cls
+      (#match? @_cls "^(Map|WeakMap|Set)$")))) @node

package/packages/chunker/src/queries/typescript/symbols.scm

@@ -0,0 +1,79 @@
+; TypeScript symbol extraction queries
+; Captures: @node (full declaration), @name (identifier), @kind (implicit from pattern)
+
+; === Exported declarations ===
+
+; export function foo() {}
+; export async function foo() {}
+(export_statement
+  (function_declaration
+    name: (identifier) @name) @node) @exported
+
+; export class Foo {}
+(export_statement
+  (class_declaration
+    name: (type_identifier) @name) @node) @exported
+
+; export interface IFoo {}
+(export_statement
+  (interface_declaration
+    name: (type_identifier) @name) @node) @exported
+
+; export type MyType = ...
+(export_statement
+  (type_alias_declaration
+    name: (type_identifier) @name) @node) @exported
+
+; export enum Color {}
+(export_statement
+  (enum_declaration
+    name: (identifier) @name) @node) @exported
+
+; export const FOO = ...
+(export_statement
+  (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name)) @node) @exported
+
+; export default class Foo {}
+(export_statement
+  "default"
+  (class_declaration
+    name: (type_identifier) @name) @node) @exported
+
+; === Non-exported declarations ===
+
+; function foo() {}
+(function_declaration
+  name: (identifier) @name) @node
+
+; class Foo {}
+(class_declaration
+  name: (type_identifier) @name) @node
+
+; interface IFoo {}
+(interface_declaration
+  name: (type_identifier) @name) @node
+
+; type MyType = ...
+(type_alias_declaration
+  name: (type_identifier) @name) @node
+
+; enum Color {}
+(enum_declaration
+  name: (identifier) @name) @node
+
+; const foo = ...
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @name)) @node
+
+; === Class members ===
+
+; class methods: foo() {} / async foo() {} / static foo() {}
+(method_definition
+  name: (property_identifier) @name) @node
+
+; class properties: foo = value / readonly foo: Type
+(public_field_definition
+  name: (property_identifier) @name) @node

package/packages/cli/dist/aikit-init.d.ts

@@ -0,0 +1,54 @@
+import { KBConfig } from "../../core/dist/index.js";
+import { IEmbedder } from "../../embeddings/dist/index.js";
+import { IncrementalIndexer } from "../../indexer/dist/index.js";
+import { IGraphStore, IKnowledgeStore } from "../../store/dist/index.js";
+
+//#region packages/cli/src/aikit-init.d.ts
+interface ICuratedManager {
+  reindexAll(): Promise<{
+    indexed: number;
+  }>;
+  remember(title: string, content: string, category: string, tags?: string[]): Promise<{
+    path: string;
+  }>;
+  update(relativePath: string, newContent: string, reason: string): Promise<{
+    path: string;
+    version: number;
+  }>;
+  forget(relativePath: string, reason: string): Promise<{
+    path: string;
+  }>;
+  read(relativePath: string): Promise<{
+    path: string;
+    title: string;
+    category: string;
+    tags: string[];
+    version: number;
+    content: string;
+  }>;
+  list(filters?: {
+    category?: string;
+    tag?: string;
+  }): Promise<Array<{
+    path: string;
+    title: string;
+    category: string;
+    tags: string[];
+    version: number;
+    contentPreview: string;
+  }>>;
+}
+interface KBContext {
+  config: KBConfig;
+  embedder: IEmbedder;
+  store: IKnowledgeStore;
+  graphStore: IGraphStore;
+  indexer: IncrementalIndexer;
+  curated: ICuratedManager;
+}
+/**
+ * Initialize all KB components for CLI use.
+ */
+declare function initKB(): Promise<KBContext>;
+//#endregion
+export { KBContext, initKB };

package/packages/cli/dist/aikit-init.js

@@ -0,0 +1 @@
+import{existsSync as e,readFileSync as t}from"node:fs";import{dirname as n,resolve as r}from"node:path";import{initializeWasm as i}from"../../chunker/dist/index.js";import{AIKIT_PATHS as a,getPartitionDir as o,isUserInstalled as s,registerWorkspace as c}from"../../core/dist/index.js";import{OnnxEmbedder as l}from"../../embeddings/dist/index.js";import{IncrementalIndexer as u}from"../../indexer/dist/index.js";import{SqliteGraphStore as d,createStore as f}from"../../store/dist/index.js";function p(){let i=process.env.AIKIT_CONFIG_PATH??(e(r(process.cwd(),`kb.config.json`))?r(process.cwd(),`kb.config.json`):null);if(!i)return m();let a=t(i,`utf-8`),o;try{o=JSON.parse(a)}catch{console.error(`Failed to parse ${i} as JSON. Ensure the file contains valid JSON.`),process.exit(1)}let s=n(i);return o.sources=o.sources.map(e=>({...e,path:r(s,e.path)})),o.store.path=r(s,o.store.path),o.curated=o.curated??{path:`curated`},o.curated.path=r(s,o.curated.path),h(o,s),o}function m(){let e=process.env.AIKIT_WORKSPACE_ROOT??process.cwd(),t={sources:[{path:e,excludePatterns:[`node_modules/**`,`dist/**`,`.git/**`,`coverage/**`,`*.lock`,`pnpm-lock.yaml`]}],serverName:`knowledge-base`,indexing:{chunkSize:1500,chunkOverlap:200,minChunkSize:100},embedding:{model:`mixedbread-ai/mxbai-embed-large-v1`,dimensions:1024},store:{backend:`lancedb`,path:r(e,a.data)},curated:{path:r(e,a.aiCurated)}};return h(t,e),t}function h(e,t){if(!s())return;let n=c(t);e.store.path=r(o(n.partition)),e.curated||={path:r(t,a.aiCurated)}}async function g(){let e=p(),t=new l({model:e.embedding.model,dimensions:e.embedding.dimensions});await t.initialize();let n=await f({backend:e.store.backend,path:e.store.path});await n.initialize();let r=new u(t,n),{CuratedKnowledgeManager:a}=await import(`../../server/dist/curated-manager.js`),o=new a(e.curated.path,n,t),s;try{let t=new d({path:e.store.path});await t.initialize(),s=t,r.setGraphStore(s)}catch(e){console.error(`[kb] Graph store init failed (non-fatal): ${e.message}`),s={initialize:async()=>{},upsertNode:async()=>{},upsertEdge:async()=>{},upsertNodes:async()=>{},upsertEdges:async()=>{},getNode:async()=>null,getNeighbors:async()=>({nodes:[],edges:[]}),traverse:async()=>({nodes:[],edges:[]}),findNodes:async()=>[],findEdges:async()=>[],deleteNode:async()=>{},deleteBySourcePath:async()=>0,clear:async()=>{},getStats:async()=>({nodeCount:0,edgeCount:0,nodeTypes:{},edgeTypes:{}}),validate:async()=>({valid:!0,orphanNodes:[],danglingEdges:[],stats:{nodeCount:0,edgeCount:0,nodeTypes:{},edgeTypes:{}}}),close:async()=>{}}}return await i().catch(()=>{}),{config:e,embedder:t,store:n,graphStore:s,indexer:r,curated:o}}export{g as initKB};

package/packages/cli/dist/commands/analyze.d.ts

@@ -0,0 +1,6 @@
+import { Command } from "../types.js";
+
+//#region packages/cli/src/commands/analyze.d.ts
+declare const analyzeCommands: Command[];
+//#endregion
+export { analyzeCommands };

package/packages/cli/dist/commands/analyze.js

@@ -0,0 +1,2 @@
+import{resolve as e}from"node:path";const t=[{name:`analyze`,description:`Run analyzer output for a path`,usage:`aikit analyze <type> <path>`,run:async t=>{let n=t.shift()?.trim()??``,r=t.shift()?.trim()??``;(!n||!r)&&(console.error(`Usage: aikit analyze <type> <path>`),console.error(`Types: structure, deps, symbols, patterns, entry-points, blast-radius, diagram`),process.exit(1));let{BlastRadiusAnalyzer:i,DependencyAnalyzer:a,DiagramGenerator:o,EntryPointAnalyzer:s,PatternAnalyzer:c,StructureAnalyzer:l,SymbolAnalyzer:u}=await import(`../../../analyzers/dist/index.js`),d=e(r),f;switch(n){case`structure`:f=await new l().analyze(d,{format:`markdown`});break;case`deps`:case`dependencies`:f=await new a().analyze(d,{format:`markdown`});break;case`symbols`:f=await new u().analyze(d,{format:`markdown`});break;case`patterns`:f=await new c().analyze(d,{format:`markdown`});break;case`entry-points`:f=await new s().analyze(d,{format:`markdown`});break;case`blast-radius`:f=await new i().analyze(process.cwd(),{files:[r],format:`markdown`});break;case`diagram`:f=await new o().analyze(d,{diagramType:`architecture`});break;default:console.error(`Unknown analyze type: ${n}`),console.error(`Types: structure, deps, symbols, patterns, entry-points, blast-radius, diagram`),process.exit(1)}console.log(f.output)}},{name:`onboard`,description:`Run all analyses for first-time codebase onboarding`,usage:`aikit onboard <path> [--generate] [--out-dir <dir>]`,run:async t=>{let{onboard:n}=await import(`../../../tools/dist/index.js`),r=``,i=`memory`,a;for(let e=0;e<t.length;e++){let n=t[e].trim();n===`--generate`?i=`generate`:n===`--out-dir`&&e+1<t.length?a=t[++e].trim():n.startsWith(`--`)||(r=n)}r||=process.cwd();let o=e(r);console.log(`Onboarding: ${o} (mode: ${i})`),console.log(`Running analyses...
+`);let s=await n({path:o,mode:i,outDir:a});for(let e of s.steps){let t=e.status===`success`?`✓`:`✗`,n=e.status===`success`?`${e.durationMs}ms, ${e.output.length} chars`:e.error;console.log(`  ${t} ${e.name} — ${n}`)}console.log(`\nTotal: ${s.totalDurationMs}ms`),s.outDir&&console.log(`Output written to: ${s.outDir}`)}}];export{t as analyzeCommands};

package/packages/cli/dist/commands/context-cmds.d.ts

@@ -0,0 +1,6 @@
+import { Command } from "../types.js";
+
+//#region packages/cli/src/commands/context-cmds.d.ts
+declare const contextCommands: Command[];
+//#endregion
+export { contextCommands };

package/packages/cli/dist/commands/context-cmds.js

@@ -0,0 +1 @@
+import{extractBoolFlag as e,extractNumFlag as t,extractStrFlag as n,parseRecordString as r,printCheckpoint as i,printDiffFiles as a,printFileSummary as o,printGitContext as s,printParsedOutput as c,readStdin as l}from"../helpers.js";import{resolve as u}from"node:path";import{checkpointLatest as d,checkpointList as f,checkpointLoad as p,checkpointSave as m,diffParse as h,fileSummary as g,gitContext as _,parseOutput as v}from"../../../tools/dist/index.js";const y=[{name:`parse-output`,description:`Parse build or tool output from stdin`,usage:`aikit parse-output [--tool tsc|vitest|biome|git-status]`,run:async e=>{let t=n(e,`--tool`,``).trim()||void 0,r=await l();r.trim()||(console.error(`Usage: aikit parse-output [--tool tsc|vitest|biome|git-status]`),process.exit(1)),c(v(r,t))}},{name:`git`,description:`Show git branch, status, recent commits, and optional diff stats`,usage:`aikit git [--cwd path] [--commit-count N] [--diff]`,run:async r=>{s(await _({cwd:n(r,`--cwd`,``).trim()||void 0,commitCount:t(r,`--commit-count`,5),includeDiff:e(r,`--diff`)}))}},{name:`diff`,description:`Parse unified diff text from stdin into structured file changes`,usage:`git diff | aikit diff`,run:async()=>{let e=await l();e.trim()||(console.error(`Usage: git diff | aikit diff`),process.exit(1)),a(h({diff:e}))}},{name:`summarize`,description:`Show a structural summary of a file`,usage:`aikit summarize <path>`,run:async e=>{let t=e.shift()?.trim();t||(console.error(`Usage: aikit summarize <path>`),process.exit(1)),o(await g({path:u(t)}))}},{name:`checkpoint`,description:`Save and restore lightweight session checkpoints`,usage:`aikit checkpoint <save|load|list|latest> [label-or-id] [--data json] [--notes text]`,run:async e=>{let t=e.shift()?.trim();switch(t||(console.error(`Usage: aikit checkpoint <save|load|list|latest> [label-or-id] [--data json] [--notes text]`),process.exit(1)),t){case`save`:{let t=e.shift()?.trim(),a=n(e,`--data`,``),o=n(e,`--notes`,``).trim()||void 0,s=a.trim()?``:await l();t||(console.error(`Usage: kb checkpoint save <label> [--data json] [--notes text]`),process.exit(1)),i(m(t,r(a||s),{notes:o}));return}case`load`:{let t=e.shift()?.trim();t||(console.error(`Usage: kb checkpoint load <id>`),process.exit(1));let n=p(t);if(!n){console.log(`No checkpoint found: ${t}`);return}i(n);return}case`list`:{let e=f();if(e.length===0){console.log(`No checkpoints saved.`);return}console.log(`Checkpoints (${e.length})`),console.log(`─`.repeat(60));for(let t of e)console.log(`${t.id}`),console.log(`  Label: ${t.label}`),console.log(`  Created: ${t.createdAt}`);return}case`latest`:{let e=d();if(!e){console.log(`No checkpoints saved.`);return}i(e);return}default:console.error(`Unknown checkpoint action: ${t}`),console.error(`Actions: save, load, list, latest`),process.exit(1)}}}];export{y as contextCommands};

package/packages/cli/dist/commands/environment.d.ts

@@ -0,0 +1,6 @@
+import { Command } from "../types.js";
+
+//#region packages/cli/src/commands/environment.d.ts
+declare const environmentCommands: Command[];
+//#endregion
+export { environmentCommands };