@vpxa/aikit 0.1.308 → 0.1.309

package/scaffold/dist/definitions/skills/typescript.mjs

@@ -12,125 +12,85 @@ metadata:
 
 # TypeScript
 
-> Comprehensive TypeScript development patterns — type system performance, compiler configuration, advanced types, type safety, async patterns, module organization, and runtime optimization. Synthesized from pproenca TypeScript rules, TypeScript 6.0 features, wshobson advanced types and modern JS patterns, and Jeffallan typescript-pro patterns.
+Use for TypeScript implementation/review, public APIs, type safety, compiler config, async/runtime boundaries, and type-check performance.
 
 ## Mindset
 
-Type errors are specifications, not obstacles. Every red squiggle is the compiler telling you about a contract violation BEFORE runtime. Your job is to make impossible states unrepresentable — if the type system allows an invalid value, the design is wrong.
+Types are executable contracts. Prefer designs where invalid states cannot be expressed, but keep types readable and fast enough for humans and compiler.
 
-Think in terms of: narrowing (make types more specific at each step), branding (distinguish structurally identical types by meaning), and exhaustiveness (force the compiler to verify all cases are handled).
+## Core Rules
 
-## When to Use
+- Avoid any in exported signatures; use unknown, generics, unions, and narrowing.
+- Avoid as to silence errors; use guards/assertion fns or fix upstream types. Test mocks may use contained as unknown as T.
+- Avoid non-null ! without runtime guard.
+- Prefer undefined for optional/missing and null for explicit empty; follow repo convention.
+- Prefer as const objects or literal unions over new enum usage.
+- Export readonly/public types when mutation is not part of contract.
+- Keep runtime validation at trust boundaries; TypeScript does not validate external data.
 
-**MANDATORY** for the Implementer agent on every TypeScript task. Also use when:
-- Writing or reviewing TypeScript code
-- Configuring \`tsconfig.json\` or compiler options
-- Designing type-safe APIs, libraries, or utilities
-- Optimizing type-check performance or build times
+## Compiler Config
 
-## NEVER
+Baseline for app/library code:
+- strict, noUncheckedIndexedAccess, exactOptionalPropertyTypes, noFallthroughCasesInSwitch.
+- isolatedModules and verbatimModuleSyntax for modern bundlers.
+- incremental for local speed; composite/declaration/declarationMap for referenced packages.
+- skipLibCheck acceptable for apps; be stricter for published libs when feasible.
 
-- **NEVER use \`as\` to silence type errors** — it hides bugs. Use type guards, assertion functions, or fix the upstream type instead. \`as\` is only acceptable for test mocks with \`as unknown as T\` pattern.
-- **NEVER use \`any\` in exported signatures** — it infects every consumer. Use \`unknown\` + narrowing, generics, or explicit union types. \`any\` in implementation internals is tolerable if contained.
-- **NEVER use \`!\` (non-null assertion) without a runtime guard** — it's a lie to the compiler. If you're sure it's not null, prove it with an \`if\` check or \`?? throw\`.
-- **NEVER mix null and undefined semantics** — pick one convention per codebase. Prefer \`undefined\` for "not set" (matches optional properties), \`null\` for "explicitly empty" (matches DOM/JSON).
-- **NEVER export mutable state as a shared type** — use \`readonly\` modifier, \`Readonly<T>\`, or \`ReadonlyArray<T>\`. Mutable shared state causes action-at-a-distance bugs that types cannot catch.
-- **NEVER use \`enum\` in new code** — use \`as const\` objects or string literal unions. Enums have runtime cost, tree-shaking issues, and numeric enums allow unsafe access.
-- **NEVER ignore generic constraints** — if a function works on "any array", type it as \`T extends readonly unknown[]\`, not \`T[]\`. Constraints document intent and catch misuse at call sites.
+## Type Design
 
-## Type System Performance
+Use:
+- Discriminated unions for variants/state machines.
+- Exhaustive never checks in switches.
+- Branded types for semantically different IDs/strings.
+- Result<T, E> or explicit error unions when callers must handle failure.
+- interface extends for object extension; type for unions/mapped/conditional types.
+- satisfies to check object shape while preserving literal types.
 
-These rules prevent slow type-checking and IDE lag:
+Avoid:
+- Deep recursive conditional types in hot paths.
+- Giant inferred return types on exported fns.
+- Generic APIs without constraints.
+- Ambient globals unless truly platform-level.
 
-### Prefer Flat Unions Over Deep Conditionals
-\`\`\`tsx
-// BAD — O(n²) type checking with deep conditionals
-type DeepResolve<T> = T extends Promise<infer U> ? DeepResolve<U> : T extends Array<infer V> ? DeepResolve<V>[] : T;
+## Performance
 
-// GOOD — flat unions check in O(n)
-type Status = "idle" | "loading" | "success" | "error";
-type Result = SuccessResult | ErrorResult | PendingResult;
-\`\`\`
+Slow typechecking signs: deep conditional recursion, huge unions, circular references, inferred public return types, mapped types over broad keys.
 
-### Interface Extends Over Intersection
-\`\`\`tsx
-// BAD — intersection types are expensive to compute
-type Extended = BaseType & { extra: string } & { more: number };
+Fix order:
+1. Annotate public/complex returns.
+2. Flatten unions and split types.
+3. Replace intersections of object shapes with interfaces.
+4. Limit recursion depth or move complexity to runtime validation.
+5. Use project references for package boundaries.
 
-// GOOD — interface extends is cached by the compiler
-interface Extended extends BaseType {
-  extra: string;
-  more: number;
-}
-\`\`\`
+## Async + Runtime Boundaries
 
-### Rules
-- **Avoid recursive conditional types** deeper than 3 levels — use iterative mapped types instead
-- **Minimize computed types** in hot paths (function parameters, return types used in many places)
-- **Use \`interface\` for object shapes**, \`type\` for unions, intersections, and mapped types
-- **Annotate complex return types** explicitly — don't force the compiler to infer through 5 layers
-- **Avoid generic defaults that trigger deep inference** — provide explicit type arguments at call sites
-- **Break circular type references** — extract shared shapes into separate interfaces
+- Model loading/error/empty states explicitly.
+- Parse external input with schema/guard before trusting it.
+- Preserve causes when wrapping errors.
+- Type async cancellation/timeouts explicitly when API supports them.
+- Keep JSON-compatible types separate from rich runtime objects.
 
-## Compiler Configuration
+## Module Hygiene
 
-### Strict Mode (all projects)
-\`\`\`jsonc
-{
-  "compilerOptions": {
-    "strict": true,                    // Enables ALL strict checks
-    "noUncheckedIndexedAccess": true,  // arr[0] is T | undefined
-    "exactOptionalProperties": true,   // undefined ≠ missing
-    "noFallthroughCasesInSwitch": true,
-    "forceConsistentCasingInFileNames": true,
-    "isolatedModules": true,           // Required for most bundlers
-    "verbatimModuleSyntax": true       // Explicit import/export type
-  }
-}
-\`\`\`
+- Use import type / export type for type-only edges.
+- Avoid barrel files that create cycles or hide heavy imports.
+- Keep public API types stable; changing exported shapes is a contract change.
+- Match repo path alias/import convention; do not invent one.
 
-### Build Performance
-\`\`\`jsonc
-{
-  "compilerOptions": {
-    "incremental": true,               // Cache type-check results
-    "tsBuildInfoFile": ".tsbuildinfo",
-    "skipLibCheck": true               // Skip .d.ts checking (safe for apps)
-  }
-}
-\`\`\`
+## Validation Before Done
 
-### Project References (monorepos)
-\`\`\`jsonc
-// tsconfig.json (root)
-{
-  "references": [
-    { "path": "packages/core" },
-    { "path": "packages/server" },
-    { "path": "packages/cli" }
-  ]
-}
+Run check({}) or tsc --noEmit equivalent, plus relevant tests. For type-only changes, add compile-time assertions or tests where repo patterns support them.
 
-// packages/core/tsconfig.json
-{
-  "compilerOptions": {
-    "composite": true,
-    "declaration": true,
-    "declarationMap": true
-  }
-}
-\`\`\`
+## References
 
-### TypeScript 6.0+ Features
-- **\`#/\` subpath imports**: \`import { utils } from "#/lib/utils"\` — no more \`../../../\` relative paths. Configure in \`package.json\` \`"imports"\` field.
-- **\`es2025\` target**: Set, Iterator, Promise.withResolvers, RegExp v flag
-- **\`--noCheck\`**: Skip type-checking in CI (when pre-checked) for faster builds
-- **\`--stableTypeOrdering\`**: Deterministic declaration output for reproducible builds
-- **\`isolatedDeclarations\`**: Generate \`.d.ts\` without type-checking — enables parallel builds
+Load on demand:
+- references/advanced-types.md — Conditional types, mapped types, template literal types, utility patterns with code examples.
+- references/patterns-and-perf.md — Type system performance rules, compiler config details, never rules, async/runtime module patterns.
+`},{file:`references/advanced-types.md`,content:`# Advanced Types
 
-## Advanced Types
+## Constrained Generics
 
-### Constrained Generics
 \`\`\`tsx
 // Constrain to ensure property exists
 function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
@@ -143,7 +103,8 @@ function merge<T extends Record<string, unknown>>(target: T, source: Partial<T>)
 }
 \`\`\`
 
-### Conditional Types
+## Conditional Types
+
 \`\`\`tsx
 // Extract return type from async function
 type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
@@ -155,7 +116,8 @@ type NonNullableDeep<T> = T extends null | undefined ? never : T extends object
 type Parameters<T> = T extends (...args: infer P) => unknown ? P : never;
 \`\`\`
 
-### Mapped Types
+## Mapped Types
+
 \`\`\`tsx
 // Make all properties optional recursively
 type DeepPartial<T> = { [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P] };
@@ -167,7 +129,8 @@ type Mutable<T> = { -readonly [P in keyof T]: T[P] };
 type Getters<T> = { [K in keyof T as \`get\${Capitalize<string & K>}\`]: () => T[K] };
 \`\`\`
 
-### Template Literal Types
+## Template Literal Types
+
 \`\`\`tsx
 // Event name typing
 type EventName<T extends string> = \`on\${Capitalize<T>}\`;
@@ -183,7 +146,8 @@ type ExtractParams<T extends string> =
 type Params = ExtractParams<"/users/:id/posts/:postId">; // "id" | "postId"
 \`\`\`
 
-### Utility Type Patterns
+## Utility Type Patterns
+
 \`\`\`tsx
 // Deep readonly
 type DeepReadonly<T> = { readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P] };
@@ -199,9 +163,8 @@ type Paths<T, D extends number = 3> = [D] extends [never]
     : never;
 \`\`\`
 
-## Type Safety Patterns
+## Branded Types
 
-### Branded Types
 \`\`\`tsx
 // Prevent mixing IDs of different entities
 type UserId = string & { readonly __brand: "UserId" };
@@ -214,7 +177,8 @@ function getUser(id: UserId) { /* ... */ }
 getUser(createOrderId("123")); // TS Error! OrderId is not UserId
 \`\`\`
 
-### Discriminated Unions with Exhaustive Matching
+## Discriminated Unions with Exhaustive Matching
+
 \`\`\`tsx
 type Shape =
   | { kind: "circle"; radius: number }
@@ -234,7 +198,8 @@ function area(shape: Shape): number {
 }
 \`\`\`
 
-### Result Pattern
+## Result Pattern
+
 \`\`\`tsx
 type Result<T, E = Error> = { ok: true; value: T } | { ok: false; error: E };
 
@@ -258,165 +223,132 @@ if (!result.ok) {
 }
 const config = result.value;  // Type-narrowed to Config
 \`\`\`
+`},{file:`references/patterns-and-perf.md`,content:`# TypeScript Patterns and Performance
 
-## Async Patterns
-
-### Parallel Execution
-\`\`\`tsx
-// Promise.all — fail-fast on first rejection
-const [users, posts] = await Promise.all([getUsers(), getPosts()]);
-
-// Promise.allSettled — get all results regardless of failures
-const results = await Promise.allSettled([getUsers(), getPosts(), getComments()]);
-for (const r of results) {
-  if (r.status === "fulfilled") process(r.value);
-  else logError(r.reason);
-}
-\`\`\`
+## Type System Performance
 
-### AbortController
-\`\`\`tsx
-async function fetchWithTimeout(url: string, timeoutMs: number): Promise<Response> {
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    return await fetch(url, { signal: controller.signal });
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-\`\`\`
+Prefer flat unions over deep conditional types. Deep conditionals are O(n^2) in the checker.
 
-### Async Iterators
 \`\`\`tsx
-async function* paginate<T>(fetcher: (page: number) => Promise<T[]>): AsyncGenerator<T> {
-  let page = 0;
-  while (true) {
-    const items = await fetcher(page++);
-    if (items.length === 0) break;
-    yield* items;
-  }
-}
+// BAD — deep conditional
+type DeepResolve<T> = T extends Promise<infer U> ? DeepResolve<U> : T extends Array<infer V> ? DeepResolve<V>[] : T;
 
-// Usage
-for await (const user of paginate(fetchUsersPage)) {
-  processUser(user);
-}
+// GOOD — flat unions check in O(n)
+type Status = "idle" | "loading" | "success" | "error";
 \`\`\`
 
-## Module Organization
-
-### Barrel File Performance
-\`\`\`tsx
-// BAD — barrel files cause entire module tree to load
-// index.ts
-export * from "./userService";
-export * from "./orderService";
-export * from "./paymentService";
-
-// GOOD — direct imports skip barrel overhead
-import { UserService } from "./services/userService";
-\`\`\`
+Prefer interface extends over intersection types for object shapes:
 
-### Type-Only Imports
 \`\`\`tsx
-// Always use type-only imports for types
-import type { User, CreateUserDto } from "./types";
-import { UserService } from "./userService";
-// With verbatimModuleSyntax, this is enforced
-\`\`\`
+// BAD — intersection types are expensive to compute
+type Extended = BaseType & { extra: string } & { more: number };
 
-### Re-export Patterns
-\`\`\`tsx
-// Public API surface — explicit re-exports
-export { UserService } from "./userService";
-export type { User, CreateUserDto } from "./types";
-// Don't export internal implementation details
+// GOOD — interface extends is cached by the compiler
+interface Extended extends BaseType {
+  extra: string;
+  more: number;
+}
 \`\`\`
 
-## Memory & Runtime
+### Performance Rules
+- Avoid recursive conditional types deeper than 3 levels — use iterative mapped types instead.
+- Minimize computed types in hot paths (function parameters, return types used in many places).
+- Use \`interface\` for object shapes, \`type\` for unions, intersections, and mapped types.
+- Annotate complex return types explicitly — do not force the compiler to infer through 5 layers.
+- Break circular type references by extracting shared shapes into separate interfaces.
 
-### WeakRef for Caches
-\`\`\`tsx
-class WeakCache<K extends object, V> {
-  private cache = new Map<K, WeakRef<V & object>>();
-  private registry = new FinalizationRegistry<K>(key => this.cache.delete(key));
+## Compiler Configuration (Detailed)
 
-  set(key: K, value: V & object): void {
-    this.cache.set(key, new WeakRef(value));
-    this.registry.register(value, key);
+### Strict Mode
+\`\`\`jsonc
+{
+  "compilerOptions": {
+    "strict": true,
+    "noUncheckedIndexedAccess": true,  // arr[0] is T | undefined
+    "exactOptionalPropertyTypes": true, // undefined ≠ missing
+    "noFallthroughCasesInSwitch": true,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true
   }
+}
+\`\`\`
 
-  get(key: K): V | undefined {
-    return this.cache.get(key)?.deref();
+### Build Performance
+\`\`\`jsonc
+{
+  "compilerOptions": {
+    "incremental": true,
+    "tsBuildInfoFile": ".tsbuildinfo",
+    "skipLibCheck": true
   }
 }
 \`\`\`
 
-### Efficient Data Structures
-\`\`\`tsx
-// Use Map/Set for frequent lookups
-const userIndex = new Map<string, User>();       // O(1) lookup
-const activeIds = new Set<string>();              // O(1) has/add/delete
+### Project References (monorepos)
+\`\`\`jsonc
+// tsconfig.json (root)
+{ "references": [{ "path": "packages/core" }, { "path": "packages/server" }] }
 
-// NOT plain objects for dynamic keys
-const userIndex: Record<string, User> = {};      // Slower for frequent mutations
+// packages/core/tsconfig.json
+{ "compilerOptions": { "composite": true, "declaration": true, "declarationMap": true } }
 \`\`\`
 
-### Runtime Rules
-- Minimize \`Reflect.metadata\` and decorator reflection — adds runtime overhead
-- Prefer \`structuredClone()\` over \`JSON.parse(JSON.stringify())\` for deep cloning
-- Use \`Object.freeze()\` for truly immutable constants
-- Avoid \`eval()\`, \`new Function()\`, and dynamic \`require()\` — security + performance issues
+### TypeScript 6.0+ Features
+- \`#/\` subpath imports: \`import { utils } from "#/lib/utils"\` — configured in \`package.json\` \`"imports"\` field.
+- \`--noCheck\`: Skip type-checking in CI when pre-checked for faster builds.
+- \`isolatedDeclarations\`: Generate .d.ts without type-checking for parallel builds.
 
-## Modern JavaScript Patterns
+## Never Rules
 
-### Nullish Handling
-\`\`\`tsx
-const port = config.port ?? 3000;          // Only for null/undefined
-const name = user?.profile?.displayName;   // Optional chaining
-const normalized = (input ??= defaultValue); // Nullish assignment
-\`\`\`
+- NEVER use \`as\` to silence type errors — use type guards or fix upstream types. Only \`as unknown as T\` in tests.
+- NEVER use \`any\` in exported signatures — it infects every consumer. Use \`unknown\` + narrowing.
+- NEVER use \`!\` (non-null assertion) without a runtime guard.
+- NEVER mix null and undefined semantics — pick one convention per codebase.
+- NEVER export mutable state as a shared type — use \`readonly\` or \`Readonly<T>\`.
+- NEVER use \`enum\` in new code — use \`as const\` objects or string literal unions.
+- NEVER ignore generic constraints — type parameters should document intent.
 
-### Immutable Updates
-\`\`\`tsx
-// Object spread for shallow updates
-const updated = { ...user, name: "New Name" };
+## Async Patterns
 
-// structuredClone for deep copy
-const deep = structuredClone(complexObject);
+\`\`\`tsx
+// Parallel execution — fail-fast
+const [users, posts] = await Promise.all([getUsers(), getPosts()]);
 
-// Array immutable operations
-const added = [...items, newItem];
-const removed = items.filter(i => i.id !== targetId);
-const updated = items.map(i => i.id === targetId ? { ...i, ...changes } : i);
-\`\`\`
+// All results regardless of failures
+const results = await Promise.allSettled([getUsers(), getPosts()]);
 
-### Pipe Pattern
-\`\`\`tsx
-function pipe<T>(value: T, ...fns: Array<(v: unknown) => unknown>): unknown {
-  return fns.reduce((acc, fn) => fn(acc), value as unknown);
+// AbortController for timeout
+async function fetchWithTimeout(url: string, timeoutMs: number): Promise<Response> {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try { return await fetch(url, { signal: controller.signal }); }
+  finally { clearTimeout(timeout); }
 }
 
-// Usage
-const result = pipe(
-  rawData,
-  validate,
-  normalize,
-  transform,
-  serialize
-);
+// Async iterator for pagination
+async function* paginate<T>(fetcher: (page: number) => Promise<T[]>): AsyncGenerator<T> {
+  let page = 0;
+  while (true) {
+    const items = await fetcher(page++);
+    if (items.length === 0) break;
+    yield* items;
+  }
+}
 \`\`\`
 
-## Decision Flow
+## Module Organization
+
+- Direct imports over barrel files — barrels cause entire module trees to load.
+- Always use \`import type\` for types.
+- Re-export public API surface explicitly; do not export internal implementation details.
+- Use named exports, not default exports.
 
-When writing TypeScript:
+## Memory and Runtime
 
-1. **Interface or Type?** → Object shape = interface. Union/intersection/mapped = type.
-2. **Generic needed?** → If the function works with multiple types and you need to preserve the type → yes. Otherwise keep it simple.
-3. **Strict enough?** → Enable all strict flags. Use branded types for domain IDs. Use discriminated unions for variants.
-4. **Performance?** → Check: Are there deep conditional types? Circular references? Massive unions? Simplify if so.
-5. **Import style?** → \`import type\` for types. Direct imports, not barrel files. Named exports, not default.
-6. **Error handling?** → Result pattern for expected errors. throw for unexpected/programmer errors.
-7. **Async?** → Promise.all for parallel. AbortController for timeouts. AsyncGenerator for streams.
+- Use \`structuredClone()\` over \`JSON.parse(JSON.stringify())\` for deep cloning.
+- Use \`Object.freeze()\` for truly immutable constants.
+- Use Map/Set for frequent lookups instead of plain objects.
+- Minimize \`Reflect.metadata\` and decorator reflection — adds runtime overhead.
+- Avoid \`eval()\`, \`new Function()\`, and dynamic \`require()\`.
 `}];export{e as default};

package/packages/server/dist/server-stdio-CBmXDMpq.js

@@ -1 +0,0 @@
-import{n as e}from"./workspace-bootstrap-BPWA6BVf.js";import{n as t,t as n}from"./startup-maintenance-D0Uhpi3k.js";import{createLogger as r,serializeError as i,setDetailedErrorLoggingEnabled as a}from"../../core/dist/index.js";const o=r(`server`);async function s(r){let[{loadConfig:s,reconfigureForWorkspace:c,resolveIndexMode:l},{createLazyServer:u},{checkForUpdates:d,autoUpgradeScaffold:f},{RootsListChangedNotificationSchema:p}]=await Promise.all([import(`./config-B-wvmMyo.js`),import(`./server-D6sJEw0I.js`),import(`./version-check-CggUKvv8.js`),import(`@modelcontextprotocol/sdk/types.js`)]),m=s();a(m.logging?.errorDetails===!0),m.configError&&o.warn(`Config load failure`,{error:m.configError}),o.info(`Config loaded`,{sourceCount:m.sources.length,storePath:m.store.path}),f(),setInterval(d,1440*60*1e3).unref();let h=l(m),g=u(m,h),{server:_,startInit:v,ready:y,runInitialIndex:b}=g,{StdioServerTransport:x}=await import(`@modelcontextprotocol/sdk/server/stdio.js`),S=new x;await _.connect(S),o.debug(`MCP server started`,{transport:`stdio`}),await e({config:m,indexMode:h,log:o,rootsChangedNotificationSchema:p,reconfigureForWorkspace:c,runInitialIndex:b,server:_,startInit:v,version:r});let C=null,w=null,T=!1,E=async e=>{T||(T=!0,o.info(`Shutdown signal received`,{signal:e}),C&&=(clearTimeout(C),null),w?.stop(),await import(`../../tools/dist/index.js`).then(({processStopAll:e})=>e()).catch(()=>{}),await S.close().catch(()=>void 0),await _.close().catch(()=>void 0),g.aikit&&await Promise.all([g.aikit.embedder.shutdown?.().catch(()=>{})??Promise.resolve(),g.aikit.graphStore.close().catch(()=>{}),g.aikit.closeStateStore?.().catch(()=>{})??Promise.resolve(),g.aikit.store.close().catch(()=>{})]),process.exit(0))},D=()=>{C&&clearTimeout(C),C=setTimeout(async()=>{o.info(`Auto-shutdown: no activity for 30 minutes — releasing resources`);try{let e=g.aikit;e&&(e.embedder.shutdown?.().catch(()=>{}),e.store.releaseMemory?.(),e.graphStore.releaseMemory?.())}catch(e){o.warn(`Resource release failed during shutdown`,i(e))}},18e5),C.unref&&C.unref()};D(),process.stdin.on(`data`,()=>D()),process.stdin.on(`end`,()=>void E(`stdin-end`)),process.stdin.on(`close`,()=>void E(`stdin-close`)),process.stdin.on(`error`,()=>void E(`stdin-error`)),process.on(`SIGINT`,()=>void E(`SIGINT`)),process.on(`SIGTERM`,()=>void E(`SIGTERM`)),y.catch(e=>{o.error(`Initialization failed — server will continue with limited tools`,t(r,e))}),h===`smart`?y.then(async()=>{try{if(!g.aikit)throw Error(`AI Kit components are not available after initialization`);let{SmartIndexScheduler:e}=await import(`../../indexer/dist/index.js`),t=new e(g.aikit.indexer,m,g.aikit.store);w=t;let n=g.aikit.store;t.start(),n.onBeforeClose&&n.onBeforeClose(()=>t.stop()),g.setSmartScheduler(t),o.debug(`Smart index scheduler started (stdio mode)`)}catch(e){o.error(`Failed to start smart index scheduler`,t(r,e))}}).catch(e=>o.error(`AI Kit init failed for smart scheduler`,t(r,e))):o.warn(`Initial full indexing skipped; use aikit_reindex to index manually`,{indexMode:h}),n(y,()=>g.aikit?{curated:g.aikit.curated,stateStore:g.aikit.stateStore}:null,r)}export{s as startStdioMode};

package/packages/server/dist/server-stdio-z3_zG1HF.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-import{r as e}from"./bin.js";import{n as t,t as n}from"./startup-maintenance-L9NUOBVy.js";import{createLogger as r,serializeError as i,setDetailedErrorLoggingEnabled as a}from"../../core/dist/index.js";const o=r(`server`);async function s(r){let[{loadConfig:s,reconfigureForWorkspace:c,resolveIndexMode:l},{createLazyServer:u},{checkForUpdates:d,autoUpgradeScaffold:f},{RootsListChangedNotificationSchema:p}]=await Promise.all([import(`./config-Bx85fwRX.js`),import(`./server-BSvqfFcK.js`),import(`./version-check-CdBHTxtt.js`),import(`@modelcontextprotocol/sdk/types.js`)]),m=s();a(m.logging?.errorDetails===!0),m.configError&&o.warn(`Config load failure`,{error:m.configError}),o.info(`Config loaded`,{sourceCount:m.sources.length,storePath:m.store.path}),f(),setInterval(d,1440*60*1e3).unref();let h=l(m),g=u(m,h),{server:_,startInit:v,ready:y,runInitialIndex:b}=g,{StdioServerTransport:x}=await import(`@modelcontextprotocol/sdk/server/stdio.js`),S=new x;await _.connect(S),o.debug(`MCP server started`,{transport:`stdio`}),await e({config:m,indexMode:h,log:o,rootsChangedNotificationSchema:p,reconfigureForWorkspace:c,runInitialIndex:b,server:_,startInit:v,version:r});let C=null,w=null,T=!1,E=async e=>{T||(T=!0,o.info(`Shutdown signal received`,{signal:e}),C&&=(clearTimeout(C),null),w?.stop(),await import(`../../tools/dist/index.js`).then(({processStopAll:e})=>e()).catch(()=>{}),await S.close().catch(()=>void 0),await _.close().catch(()=>void 0),g.aikit&&await Promise.all([g.aikit.embedder.shutdown?.().catch(()=>{})??Promise.resolve(),g.aikit.graphStore.close().catch(()=>{}),g.aikit.closeStateStore?.().catch(()=>{})??Promise.resolve(),g.aikit.store.close().catch(()=>{})]),process.exit(0))},D=()=>{C&&clearTimeout(C),C=setTimeout(async()=>{o.info(`Auto-shutdown: no activity for 30 minutes — releasing resources`);try{let e=g.aikit;e&&(e.embedder.shutdown?.().catch(()=>{}),e.store.releaseMemory?.(),e.graphStore.releaseMemory?.())}catch(e){o.warn(`Resource release failed during shutdown`,i(e))}},18e5),C.unref&&C.unref()};D(),process.stdin.on(`data`,()=>D()),process.stdin.on(`end`,()=>void E(`stdin-end`)),process.stdin.on(`close`,()=>void E(`stdin-close`)),process.stdin.on(`error`,()=>void E(`stdin-error`)),process.on(`SIGINT`,()=>void E(`SIGINT`)),process.on(`SIGTERM`,()=>void E(`SIGTERM`)),y.catch(e=>{o.error(`Initialization failed — server will continue with limited tools`,t(r,e))}),h===`smart`?y.then(async()=>{try{if(!g.aikit)throw Error(`AI Kit components are not available after initialization`);let{SmartIndexScheduler:e}=await import(`../../indexer/dist/index.js`),t=new e(g.aikit.indexer,m,g.aikit.store);w=t;let n=g.aikit.store;t.start(),n.onBeforeClose&&n.onBeforeClose(()=>t.stop()),g.setSmartScheduler(t),o.debug(`Smart index scheduler started (stdio mode)`)}catch(e){o.error(`Failed to start smart index scheduler`,t(r,e))}}).catch(e=>o.error(`AI Kit init failed for smart scheduler`,t(r,e))):o.warn(`Initial full indexing skipped; use aikit_reindex to index manually`,{indexMode:h}),n(y,()=>g.aikit?{curated:g.aikit.curated,stateStore:g.aikit.stateStore}:null,r)}export{s as startStdioMode};