@vpxa/aikit 0.1.1

package/packages/enterprise-bridge/dist/types.d.ts

@@ -0,0 +1,81 @@
+//#region packages/enterprise-bridge/src/types.d.ts
+/** ER bridge configuration (subset of KBConfig.er) */
+interface ERBridgeConfig {
+  enabled: boolean;
+  baseUrl: string;
+  apiKey: string;
+  timeoutMs: number;
+  cacheTtlMs: number;
+  cacheMaxEntries: number;
+  fallbackThreshold: number;
+}
+/** Result from ER search API */
+interface ERSearchResult {
+  content: string;
+  sourcePath: string;
+  score: number;
+  metadata?: Record<string, unknown>;
+}
+/** Response from ER search API (POST /api/v1/search) */
+interface ERSearchResponse {
+  sources: Array<{
+    content: string;
+    metadata: Record<string, string>;
+    score?: number;
+    confidence?: number;
+  }>;
+  query?: string;
+  searchMode?: string;
+}
+/** Push request to ER */
+interface ERPushRequest {
+  title: string;
+  content: string;
+  category?: string;
+  tags?: string[];
+}
+/** Push response from ER */
+interface ERPushResponse {
+  pushed: boolean;
+  status: 'stored' | 'failed';
+  remotePath?: string;
+  timestamp: string;
+  error?: string;
+}
+/** Transient ER error (429, 5xx, network) — retries exhausted but not a permanent failure */
+declare class ERTransientError extends Error {
+  readonly statusCode?: number | undefined;
+  constructor(message: string, statusCode?: number | undefined);
+}
+/** Sync status entry for tracking push history */
+interface ERSyncEntry {
+  entryId: string;
+  title: string;
+  pushedAt: string;
+  status: 'stored' | 'failed';
+  remotePath?: string;
+}
+/** Cache entry wrapping ER search results */
+interface ERCacheEntry {
+  results: ERSearchResult[];
+  query: string;
+  cachedAt: number;
+  ttl: number;
+}
+/** Merged search result with source provenance */
+interface MergedSearchResult {
+  content: string;
+  sourcePath: string;
+  score: number;
+  source: 'local' | 'er';
+  startLine?: number;
+  endLine?: number;
+  contentType?: string;
+  headingPath?: string;
+  origin?: string;
+  category?: string;
+  tags?: string[];
+  metadata?: Record<string, unknown>;
+}
+//#endregion
+export { ERBridgeConfig, ERCacheEntry, ERPushRequest, ERPushResponse, ERSearchResponse, ERSearchResult, ERSyncEntry, ERTransientError, MergedSearchResult };

package/packages/enterprise-bridge/dist/types.js

@@ -0,0 +1 @@
+var e=class extends Error{constructor(e,t){super(e),this.statusCode=t,this.name=`ERTransientError`}};export{e as ERTransientError};

package/packages/flows/dist/adapters/claude-plugin.d.ts

@@ -0,0 +1,12 @@
+import { FlowFormatAdapter, FlowManifest } from "../types.js";
+
+//#region packages/flows/src/adapters/claude-plugin.d.ts
+declare class ClaudePluginAdapter implements FlowFormatAdapter {
+  readonly format: "claude-plugin";
+  detect(sourceDir: string): boolean;
+  parse(sourceDir: string): Promise<FlowManifest>;
+  private discoverSteps;
+  private discoverAgents;
+}
+//#endregion
+export { ClaudePluginAdapter };

package/packages/flows/dist/adapters/claude-plugin.js

@@ -0,0 +1 @@
+import{existsSync as e,readFileSync as t,readdirSync as n}from"node:fs";import{basename as r,join as i}from"node:path";const a=[`spec`,`plan`,`task`,`execute`,`verify`];var o=class{format=`claude-plugin`;detect(t){return e(i(t,`.claude-plugin`,`plugin.json`))}async parse(e){let n=i(e,`.claude-plugin`,`plugin.json`),a=JSON.parse(t(n,`utf-8`)),o=this.discoverSteps(e),s=this.discoverAgents(e);return{name:a.name??r(e),version:a.version??`1.0.0`,description:a.description??``,author:a.author,steps:o,agents:s,artifacts_dir:`.spec`,install:[]}}discoverSteps(t){let r=i(t,`skills`);if(!e(r))return[];let o=n(r,{withFileTypes:!0}).filter(e=>e.isDirectory()).map(e=>e.name).sort((e,t)=>{let n=a.indexOf(e),r=a.indexOf(t);return n!==-1&&r!==-1?n-r:n===-1?r===-1?e.localeCompare(t):1:-1});return o.map((e,t)=>({id:e,name:e.charAt(0).toUpperCase()+e.slice(1),skill:`skills/${e}/SKILL.md`,produces:[`${e}.md`],requires:t>0?[o[t-1]]:[],agents:[],description:`${e} step`}))}discoverAgents(t){let r=i(t,`agents`);return e(r)?n(r,{withFileTypes:!0}).filter(e=>e.isFile()&&e.name.endsWith(`.md`)).map(e=>`agents/${e.name}`):[]}};export{o as ClaudePluginAdapter};

package/packages/flows/dist/adapters/copilot.d.ts

@@ -0,0 +1,10 @@
+import { FlowFormatAdapter, FlowManifest } from "../types.js";
+
+//#region packages/flows/src/adapters/copilot.d.ts
+declare class CopilotAdapter implements FlowFormatAdapter {
+  readonly format: "copilot";
+  detect(sourceDir: string): boolean;
+  parse(sourceDir: string): Promise<FlowManifest>;
+}
+//#endregion
+export { CopilotAdapter };

package/packages/flows/dist/adapters/copilot.js

@@ -0,0 +1 @@
+import{existsSync as e,readdirSync as t}from"node:fs";import{basename as n,join as r}from"node:path";var i=class{format=`copilot`;detect(t){return e(r(t,`.github`,`agents`))}async parse(e){let i=t(r(e,`.github`,`agents`),{withFileTypes:!0}).filter(e=>e.isFile()&&e.name.endsWith(`.md`)).map(e=>`.github/agents/${e.name}`),a=i.map((e,t)=>{let r=n(e,`.md`).toLowerCase().replace(/\.agent$/,``);return{id:r,name:r.charAt(0).toUpperCase()+r.slice(1),skill:e,produces:[`${r}.md`],requires:t>0?[i[t-1].replace(/.*\//,``).replace(/\.md$/,``).toLowerCase()]:[],agents:[e],description:`${r} agent step`}});return{name:n(e),version:`1.0.0`,description:`Copilot agents flow from ${n(e)}`,steps:a,agents:i,artifacts_dir:`.spec`,install:[]}}};export{i as CopilotAdapter};

package/packages/flows/dist/adapters/index.d.ts

@@ -0,0 +1,11 @@
+import { FlowFormat, FlowFormatAdapter } from "../types.js";
+import { ClaudePluginAdapter } from "./claude-plugin.js";
+import { CopilotAdapter } from "./copilot.js";
+import { NativeAdapter } from "./native.js";
+
+//#region packages/flows/src/adapters/index.d.ts
+declare function detectFormat(sourceDir: string): FlowFormat | null;
+declare function getAdapter(format: FlowFormat): FlowFormatAdapter;
+declare function getAdapterForSource(sourceDir: string): FlowFormatAdapter | null;
+//#endregion
+export { ClaudePluginAdapter, CopilotAdapter, NativeAdapter, detectFormat, getAdapter, getAdapterForSource };

package/packages/flows/dist/adapters/index.js

@@ -0,0 +1 @@
+import{ClaudePluginAdapter as e}from"./claude-plugin.js";import{CopilotAdapter as t}from"./copilot.js";import{NativeAdapter as n}from"./native.js";const r=[new n,new e,new t];function i(e){for(let t of r)if(t.detect(e))return t.format;return null}function a(e){let t=r.find(t=>t.format===e);if(!t)throw Error(`No adapter for format: ${e}`);return t}function o(e){for(let t of r)if(t.detect(e))return t;return null}export{e as ClaudePluginAdapter,t as CopilotAdapter,n as NativeAdapter,i as detectFormat,a as getAdapter,o as getAdapterForSource};

package/packages/flows/dist/adapters/native.d.ts

@@ -0,0 +1,10 @@
+import { FlowFormatAdapter, FlowManifest } from "../types.js";
+
+//#region packages/flows/src/adapters/native.d.ts
+declare class NativeAdapter implements FlowFormatAdapter {
+  readonly format: "native";
+  detect(sourceDir: string): boolean;
+  parse(sourceDir: string): Promise<FlowManifest>;
+}
+//#endregion
+export { NativeAdapter };

package/packages/flows/dist/adapters/native.js

@@ -0,0 +1 @@
+import{existsSync as e,readFileSync as t}from"node:fs";import{join as n}from"node:path";var r=class{format=`native`;detect(t){return e(n(t,`flow.json`))}async parse(e){let r=t(n(e,`flow.json`),`utf-8`);return JSON.parse(r)}};export{r as NativeAdapter};

package/packages/flows/dist/builtins.d.ts

@@ -0,0 +1,16 @@
+import { FlowManifest } from "./types.js";
+
+//#region packages/flows/src/builtins.d.ts
+interface BuiltinFlow {
+  /** Flow manifest */
+  manifest: FlowManifest;
+  /** Relative path within the monorepo where scaffold files live */
+  scaffoldDir: string;
+}
+/**
+ * Returns all built-in flow definitions bundled with @aikit/flows.
+ * These flows are always available, even without installation via `flow add`.
+ */
+declare function getBuiltinFlows(): BuiltinFlow[];
+//#endregion
+export { BuiltinFlow, getBuiltinFlows };

package/packages/flows/dist/builtins.js

@@ -0,0 +1 @@
+const e={name:`aikit:basic`,version:`0.1.0`,description:`Quick development flow for bug fixes, small features, and refactoring`,steps:[{id:`assess`,name:`Assessment`,skill:`skills/assess/SKILL.md`,produces:[`assessment.md`],requires:[],agents:[`Explorer`,`Researcher-Alpha`],description:`Understand scope, analyze codebase, identify approach`},{id:`implement`,name:`Implementation`,skill:`skills/implement/SKILL.md`,produces:[`progress.md`],requires:[`assessment.md`],agents:[`Implementer`,`Frontend`],description:`Write code following the assessment plan`},{id:`verify`,name:`Verification`,skill:`skills/verify/SKILL.md`,produces:[`verify-report.md`],requires:[`progress.md`],agents:[`Code-Reviewer-Alpha`,`Security`],description:`Review code, run tests, validate changes`}],agents:[],artifacts_dir:`.spec`,install:[]},t={name:`aikit:advanced`,version:`0.1.0`,description:`Full development flow for new features, API design, and architecture changes`,steps:[{id:`spec`,name:`Specification`,skill:`skills/spec/SKILL.md`,produces:[`spec.md`],requires:[],agents:[`Researcher-Alpha`],description:`Elicit requirements, clarify scope, define acceptance criteria`},{id:`plan`,name:`Planning`,skill:`skills/plan/SKILL.md`,produces:[`plan.md`],requires:[`spec.md`],agents:[`Planner`,`Explorer`],description:`Analyze codebase, design architecture, create implementation plan`},{id:`task`,name:`Task Breakdown`,skill:`skills/task/SKILL.md`,produces:[`tasks.md`],requires:[`plan.md`],agents:[`Planner`,`Architect-Reviewer-Alpha`],description:`Break plan into ordered implementation tasks with dependencies`},{id:`execute`,name:`Execution`,skill:`skills/execute/SKILL.md`,produces:[`progress.md`],requires:[`tasks.md`],agents:[`Orchestrator`,`Implementer`,`Frontend`,`Refactor`],description:`Implement all tasks, write code, write tests`},{id:`verify`,name:`Verification`,skill:`skills/verify/SKILL.md`,produces:[`verify-report.md`],requires:[`progress.md`],agents:[`Code-Reviewer-Alpha`,`Code-Reviewer-Beta`,`Architect-Reviewer-Alpha`,`Architect-Reviewer-Beta`,`Security`],description:`Dual code review, architecture review, security review, test validation`}],agents:[],artifacts_dir:`.spec`,install:[]};function n(){return[{manifest:e,scaffoldDir:`scaffold/flows/aikit-basic`},{manifest:t,scaffoldDir:`scaffold/flows/aikit-advanced`}]}export{n as getBuiltinFlows};

package/packages/flows/dist/foundation.d.ts

@@ -0,0 +1,20 @@
+import { FlowManifest } from "./types.js";
+
+//#region packages/flows/src/foundation.d.ts
+declare class FoundationIntegration {
+  /**
+   * Inject foundation preamble into a file.
+   * Replaces existing preamble if present, otherwise prepends.
+   */
+  injectPreamble(filePath: string, manifest: FlowManifest): void;
+  /**
+   * Remove foundation preamble from a file.
+   */
+  removePreamble(filePath: string): void;
+  /**
+   * Get list of IDE instruction files to inject preamble into.
+   */
+  getTargetFiles(workspaceRoot: string): string[];
+}
+//#endregion
+export { FoundationIntegration };

package/packages/flows/dist/foundation.js

@@ -0,0 +1,11 @@
+import{existsSync as e,readFileSync as t,writeFileSync as n}from"node:fs";import{join as r}from"node:path";const i=`<!-- aikit foundation context -->`,a=`<!-- end foundation context -->`;function o(e){let t=e.artifacts_dir||`.spec`;return`${i}
+You are operating within the @vpxa/aikit framework.
+- Use aikit MCP tools for all search, analysis, and memory operations
+- Follow agents defined in AGENTS.md for delegation
+- Use built-in skills (brainstorming, requirements-clarity, etc.) as needed
+- Track state via the flow state machine (flow_status, flow_step)
+- Active flow: ${e.name} v${e.version}
+- Artifacts go in: ${t}/${e.name}/
+${a}`}var s=class{injectPreamble(r,s){let c=o(s);if(!e(r)){n(r,`${c}\n`,`utf-8`);return}let l=t(r,`utf-8`),u=l.indexOf(i),d=l.indexOf(a);if(u!==-1&&d!==-1){n(r,`${l.slice(0,u)}${c}${l.slice(d+31)}`,`utf-8`);return}n(r,`${c}\n\n${l}`,`utf-8`)}removePreamble(r){if(!e(r))return;let o=t(r,`utf-8`),s=o.indexOf(i),c=o.indexOf(a);s===-1||c===-1||n(r,(o.slice(0,s)+o.slice(c+31)).replace(/^\n+/,``).replace(/\n{3,}/g,`
+
+`),`utf-8`)}getTargetFiles(t){let n=[],i=r(t,`.github`,`copilot-instructions.md`);e(i)&&n.push(i);let a=r(t,`CLAUDE.md`);e(a)&&n.push(a);let o=r(t,`AGENTS.md`);return e(o)&&n.push(o),n}};export{s as FoundationIntegration};

package/packages/flows/dist/git.d.ts

@@ -0,0 +1,34 @@
+import { FlowResult } from "./types.js";
+
+//#region packages/flows/src/git.d.ts
+declare class GitInstaller {
+  private readonly flowsDir;
+  constructor(flowsDir: string);
+  /**
+   * Clone a git repo into the flows directory.
+   * Returns the local install path.
+   */
+  clone(repoUrl: string): FlowResult<string>;
+  /**
+   * Update an existing cloned flow repo.
+   */
+  update(installPath: string): FlowResult;
+  /**
+   * Copy a local directory as a flow source.
+   */
+  copyLocal(sourcePath: string, name: string): FlowResult<string>;
+  /**
+   * Remove installed flow files.
+   */
+  remove(installPath: string): FlowResult;
+  /**
+   * Run install dependencies for a flow.
+   * Processes the `install[]` field from flow.json.
+   */
+  runInstallDeps(installEntries: string[]): FlowResult;
+  /** Extract repo name from git URL */
+  private repoNameFromUrl;
+  private ensureFlowsDir;
+}
+//#endregion
+export { GitInstaller };

package/packages/flows/dist/git.js

@@ -0,0 +1 @@
+import{cpSync as e,existsSync as t,mkdirSync as n,rmSync as r}from"node:fs";import{basename as i,join as a}from"node:path";import{execSync as o}from"node:child_process";var s=class{constructor(e){this.flowsDir=e}clone(e){let n=this.repoNameFromUrl(e),r=a(this.flowsDir,n);if(t(r))return{success:!1,error:`Flow "${n}" already installed at ${r}. Use update instead.`};try{return this.ensureFlowsDir(),o(`git clone --depth 1 ${e} ${r}`,{stdio:`pipe`,timeout:6e4}),{success:!0,data:r}}catch(e){return{success:!1,error:`Git clone failed: ${e instanceof Error?e.message:String(e)}`}}}update(e){if(!t(e))return{success:!1,error:`Install path not found: ${e}`};try{return o(`git pull --ff-only`,{cwd:e,stdio:`pipe`,timeout:6e4}),{success:!0}}catch(e){return{success:!1,error:`Git pull failed: ${e instanceof Error?e.message:String(e)}`}}}copyLocal(n,r){let i=a(this.flowsDir,r);if(t(i))return{success:!1,error:`Flow "${r}" already installed at ${i}`};try{return this.ensureFlowsDir(),e(n,i,{recursive:!0}),{success:!0,data:i}}catch(e){return{success:!1,error:`Copy failed: ${e instanceof Error?e.message:String(e)}`}}}remove(e){if(!t(e))return{success:!0};try{return r(e,{recursive:!0,force:!0}),{success:!0}}catch(e){return{success:!1,error:`Remove failed: ${e instanceof Error?e.message:String(e)}`}}}runInstallDeps(e){for(let t of e)try{if(t.startsWith(`npm:`)){o(`npx skills add ${t.slice(4)} -g`,{stdio:`pipe`,timeout:12e4});continue}if(t.endsWith(`.git`)||t.includes(`github.com`)){o(`npx skills add ${t} -g`,{stdio:`pipe`,timeout:12e4});continue}return{success:!1,error:`Unknown install entry format: ${t}`}}catch(e){return{success:!1,error:`Install dependency failed for "${t}": ${e instanceof Error?e.message:String(e)}`}}return{success:!0}}repoNameFromUrl(e){return i(e).replace(/\.git$/,``)}ensureFlowsDir(){t(this.flowsDir)||n(this.flowsDir,{recursive:!0})}};export{s as GitInstaller};

package/packages/flows/dist/index.d.ts

@@ -0,0 +1,12 @@
+import { FlowFormat, FlowFormatAdapter, FlowManifest, FlowRegistry, FlowRegistryEntry, FlowResult, FlowSourceType, FlowState, FlowStatus, FlowStep, StepAction } from "./types.js";
+import { ClaudePluginAdapter } from "./adapters/claude-plugin.js";
+import { CopilotAdapter } from "./adapters/copilot.js";
+import { NativeAdapter } from "./adapters/native.js";
+import { BuiltinFlow, getBuiltinFlows } from "./builtins.js";
+import { FoundationIntegration } from "./foundation.js";
+import { GitInstaller } from "./git.js";
+import { FlowLoader } from "./loader.js";
+import { FlowRegistryManager } from "./registry.js";
+import { FlowStateMachine } from "./state-machine.js";
+import { SymlinkManager } from "./symlinks.js";
+export { type BuiltinFlow, ClaudePluginAdapter, CopilotAdapter, type FlowFormat, type FlowFormatAdapter, FlowLoader, type FlowManifest, type FlowRegistry, type FlowRegistryEntry, FlowRegistryManager, type FlowResult, type FlowSourceType, type FlowState, FlowStateMachine, type FlowStatus, type FlowStep, FoundationIntegration, GitInstaller, NativeAdapter, type StepAction, SymlinkManager, getBuiltinFlows };

package/packages/flows/dist/index.js

@@ -0,0 +1 @@
+import{getBuiltinFlows as e}from"./builtins.js";import{FoundationIntegration as t}from"./foundation.js";import{GitInstaller as n}from"./git.js";import{ClaudePluginAdapter as r}from"./adapters/claude-plugin.js";import{CopilotAdapter as i}from"./adapters/copilot.js";import{NativeAdapter as a}from"./adapters/native.js";import{FlowLoader as o}from"./loader.js";import{FlowRegistryManager as s}from"./registry.js";import{FlowStateMachine as c}from"./state-machine.js";import{SymlinkManager as l}from"./symlinks.js";export{r as ClaudePluginAdapter,i as CopilotAdapter,o as FlowLoader,s as FlowRegistryManager,c as FlowStateMachine,t as FoundationIntegration,n as GitInstaller,a as NativeAdapter,l as SymlinkManager,e as getBuiltinFlows};

package/packages/flows/dist/loader.d.ts

@@ -0,0 +1,13 @@
+import { FlowFormat, FlowManifest, FlowResult } from "./types.js";
+
+//#region packages/flows/src/loader.d.ts
+declare class FlowLoader {
+  load(sourceDir: string): Promise<FlowResult<{
+    manifest: FlowManifest;
+    format: FlowFormat;
+  }>>;
+  loadWithFormat(sourceDir: string, format: FlowFormat): Promise<FlowResult<FlowManifest>>;
+  validate(manifest: FlowManifest): FlowResult;
+}
+//#endregion
+export { FlowLoader };

package/packages/flows/dist/loader.js

@@ -0,0 +1,2 @@
+import{getAdapter as e,getAdapterForSource as t}from"./adapters/index.js";import{existsSync as n}from"node:fs";var r=class{async load(e){if(!n(e))return{success:!1,error:`Source directory not found: ${e}`};let r=t(e);if(!r)return{success:!1,error:`No format adapter matches source: ${e}`};try{let t=await r.parse(e),n=this.validate(t);return n.success?{success:!0,data:{manifest:t,format:r.format}}:n}catch(e){return{success:!1,error:`Failed to parse flow: ${e instanceof Error?e.message:String(e)}`}}}async loadWithFormat(t,n){let r=e(n);try{let e=await r.parse(t),n=this.validate(e);return n.success?{success:!0,data:e}:n}catch(e){return{success:!1,error:`Failed to parse flow: ${e instanceof Error?e.message:String(e)}`}}}validate(e){let t=[];e.name?.trim()||t.push(`Missing flow name`),e.version?.trim()||t.push(`Missing flow version`),e.steps?.length||t.push(`Flow must have at least one step`);let n=new Set(e.steps.map(e=>e.id));for(let r of e.steps??[]){r.id?.trim()||t.push(`Step missing id`),r.skill?.trim()||t.push(`Step "${r.id}" missing skill path`);for(let e of r.requires??[])n.has(e)||t.push(`Step "${r.id}" requires unknown step "${e}"`)}return n.size!==(e.steps?.length??0)&&t.push(`Duplicate step IDs found`),t.length>0?{success:!1,error:`Validation failed:\n${t.join(`
+`)}`}:{success:!0}}};export{r as FlowLoader};

package/packages/flows/dist/registry.d.ts

@@ -0,0 +1,23 @@
+import { FlowRegistry, FlowRegistryEntry, FlowResult } from "./types.js";
+
+//#region packages/flows/src/registry.d.ts
+declare class FlowRegistryManager {
+  private readonly registryPath;
+  constructor(registryPath: string);
+  /** Load registry from disk, or create empty if missing */
+  load(): FlowRegistry;
+  /** Save registry to disk */
+  save(registry: FlowRegistry): void;
+  /** Register a new flow or update an existing one */
+  register(entry: FlowRegistryEntry): FlowResult;
+  /** Remove a flow from the registry */
+  unregister(name: string): FlowResult;
+  /** Get a specific flow entry */
+  get(name: string): FlowRegistryEntry | null;
+  /** List all registered flows */
+  list(): FlowRegistryEntry[];
+  /** Check if a flow is registered */
+  has(name: string): boolean;
+}
+//#endregion
+export { FlowRegistryManager };

package/packages/flows/dist/registry.js

@@ -0,0 +1 @@
+import{existsSync as e,mkdirSync as t,readFileSync as n,writeFileSync as r}from"node:fs";import{dirname as i}from"node:path";var a=class{constructor(e){this.registryPath=e}load(){if(!e(this.registryPath))return{version:1,flows:{}};try{let e=n(this.registryPath,`utf-8`);return JSON.parse(e)}catch{return{version:1,flows:{}}}}save(n){let a=i(this.registryPath);e(a)||t(a,{recursive:!0}),r(this.registryPath,JSON.stringify(n,null,2),`utf-8`)}register(e){let t=this.load();return t.flows[e.name]=e,this.save(t),{success:!0}}unregister(e){let t=this.load();return t.flows[e]?(delete t.flows[e],this.save(t),{success:!0}):{success:!1,error:`Flow "${e}" not found in registry`}}get(e){return this.load().flows[e]??null}list(){let e=this.load();return Object.values(e.flows)}has(e){return e in this.load().flows}};export{a as FlowRegistryManager};

package/packages/flows/dist/state-machine.d.ts

@@ -0,0 +1,23 @@
+import { FlowManifest, FlowResult, FlowState, StepAction } from "./types.js";
+
+//#region packages/flows/src/state-machine.d.ts
+declare class FlowStateMachine {
+  private readonly statePath;
+  constructor(statePath: string);
+  /** Load active flow state from disk, or null if no active flow */
+  load(): FlowState | null;
+  /** Save state to disk */
+  private save;
+  /** Start a new flow */
+  start(flowName: string, manifest: FlowManifest): FlowResult<FlowState>;
+  /** Advance the flow: next, skip, or redo current step */
+  step(action: StepAction, manifest: FlowManifest): FlowResult<FlowState>;
+  /** Get current flow status */
+  getStatus(): FlowResult<FlowState>;
+  /** Reset flow state (clear active flow) */
+  reset(): FlowResult;
+  /** Record an artifact produced by a step */
+  recordArtifact(name: string, path: string): FlowResult;
+}
+//#endregion
+export { FlowStateMachine };

package/packages/flows/dist/state-machine.js

@@ -0,0 +1 @@
+import{existsSync as e,mkdirSync as t,readFileSync as n,unlinkSync as r,writeFileSync as i}from"node:fs";import{dirname as a}from"node:path";var o=class{constructor(e){this.statePath=e}load(){if(!e(this.statePath))return null;try{let e=n(this.statePath,`utf-8`);return JSON.parse(e)}catch{return null}}save(n){let r=a(this.statePath);e(r)||t(r,{recursive:!0}),i(this.statePath,JSON.stringify(n,null,2),`utf-8`)}start(e,t){let n=this.load();if(n&&n.status===`active`)return{success:!1,error:`Flow "${n.flow}" is already active. Reset it first.`};if(!t.steps.length)return{success:!1,error:`Flow has no steps`};let r=new Date().toISOString(),i={flow:e,status:`active`,currentStep:t.steps[0].id,completedSteps:[],skippedSteps:[],artifacts:{},startedAt:r,updatedAt:r};return this.save(i),{success:!0,data:i}}step(e,t){let n=this.load();if(!n)return{success:!1,error:`No active flow`};if(n.status!==`active`)return{success:!1,error:`Flow is ${n.status}, not active`};if(!n.currentStep)return{success:!1,error:`No current step`};let r=t.steps.findIndex(e=>e.id===n.currentStep);if(r===-1)return{success:!1,error:`Current step "${n.currentStep}" not found in manifest`};let i=new Date().toISOString();switch(e){case`next`:{n.completedSteps.includes(n.currentStep)||n.completedSteps.push(n.currentStep);let e=r+1;e>=t.steps.length?(n.currentStep=null,n.status=`completed`):n.currentStep=t.steps[e].id;break}case`skip`:{n.skippedSteps.includes(n.currentStep)||n.skippedSteps.push(n.currentStep);let e=r+1;e>=t.steps.length?(n.currentStep=null,n.status=`completed`):n.currentStep=t.steps[e].id;break}case`redo`:n.completedSteps=n.completedSteps.filter(e=>e!==n.currentStep),n.skippedSteps=n.skippedSteps.filter(e=>e!==n.currentStep);break}return n.updatedAt=i,this.save(n),{success:!0,data:n}}getStatus(){let e=this.load();return e?{success:!0,data:e}:{success:!1,error:`No active flow`}}reset(){return e(this.statePath)&&r(this.statePath),{success:!0}}recordArtifact(e,t){let n=this.load();return n?(n.artifacts[e]=t,n.updatedAt=new Date().toISOString(),this.save(n),{success:!0}):{success:!1,error:`No active flow`}}};export{o as FlowStateMachine};

package/packages/flows/dist/symlinks.d.ts

@@ -0,0 +1,17 @@
+import { FlowManifest } from "./types.js";
+
+//#region packages/flows/src/symlinks.d.ts
+declare class SymlinkManager {
+  /**
+   * Create agent symlinks for a flow in the workspace.
+   */
+  createSymlinks(workspaceRoot: string, flowName: string, flowInstallPath: string, manifest: FlowManifest): void;
+  /**
+   * Remove agent symlinks for a flow.
+   */
+  removeSymlinks(workspaceRoot: string, flowName: string): void;
+  private getTargets;
+  private getAgentStem;
+}
+//#endregion
+export { SymlinkManager };

package/packages/flows/dist/symlinks.js

@@ -0,0 +1 @@
+import{copyFileSync as e,existsSync as t,mkdirSync as n,readdirSync as r,rmdirSync as i,symlinkSync as a,unlinkSync as o}from"node:fs";import{basename as s,dirname as c,join as l,relative as u}from"node:path";var d=class{createSymlinks(r,i,s,d){let f=this.getTargets(r,i);for(let r of f){t(r.baseDir)||n(r.baseDir,{recursive:!0});for(let n of d.agents){let i=l(s,n);if(!t(i))continue;let d=this.getAgentStem(n),f=l(r.baseDir,`${d}${r.extension}`);t(f)&&o(f);let p=u(c(f),i);try{a(p,f,`file`)}catch{e(i,f)}}}}removeSymlinks(e,n){let a=this.getTargets(e,n);for(let e of a)if(t(e.baseDir))try{let t=r(e.baseDir,{withFileTypes:!0});for(let n of t)!n.isFile()&&!n.isSymbolicLink()||o(l(e.baseDir,n.name));r(e.baseDir).length===0&&i(e.baseDir)}catch{}}getTargets(e,t){return[{ide:`copilot`,baseDir:l(e,`.github`,`agents`,`flows`,t),extension:`.agent.md`},{ide:`claude-code`,baseDir:l(e,`.claude`,`agents`,`flows`,t),extension:`.md`}]}getAgentStem(e){return s(e).replace(/\.agent\.md$/,``).replace(/\.md$/,``)}};export{d as SymlinkManager};

package/packages/flows/dist/types.d.ts

@@ -0,0 +1,112 @@
+//#region packages/flows/src/types.d.ts
+/**
+ * @aikit/flows — Type definitions for the pluggable flow system.
+ */
+/** A single step in a flow */
+interface FlowStep {
+  /** Unique step identifier within the flow (e.g., "spec", "plan", "execute") */
+  id: string;
+  /** Human-readable step name */
+  name: string;
+  /** Relative path to the step's SKILL.md file */
+  skill: string;
+  /** Artifact filenames this step produces */
+  produces: string[];
+  /** Step IDs this step depends on (must be completed first) */
+  requires: string[];
+  /** Agent files specific to this step (relative paths) */
+  agents: string[];
+  /** Step description */
+  description: string;
+}
+/** Flow manifest — the flow.json schema */
+interface FlowManifest {
+  /** Flow name (unique identifier) */
+  name: string;
+  /** Semantic version */
+  version: string;
+  /** Human-readable description */
+  description: string;
+  /** Author name or organization */
+  author?: string;
+  /** Ordered list of steps */
+  steps: FlowStep[];
+  /** Flow-level agent files (relative paths) */
+  agents: string[];
+  /** Directory for artifacts (default: ".spec") */
+  artifacts_dir: string;
+  /** External dependencies to install at flow-add time */
+  install: string[];
+}
+/** Source type for flow installation */
+type FlowSourceType = 'builtin' | 'git' | 'local';
+/** Detected format of the flow source */
+type FlowFormat = 'native' | 'claude-plugin' | 'copilot';
+/** Registry entry for an installed flow */
+interface FlowRegistryEntry {
+  /** Flow name */
+  name: string;
+  /** Flow version */
+  version: string;
+  /** Original source (URL, path, or "builtin") */
+  source: string;
+  /** How the flow was installed */
+  sourceType: FlowSourceType;
+  /** Absolute path where flow files are stored */
+  installPath: string;
+  /** Detected source format */
+  format: FlowFormat;
+  /** ISO timestamp when registered */
+  registeredAt: string;
+  /** ISO timestamp of last update */
+  updatedAt: string;
+  /** Parsed manifest (cached) */
+  manifest: FlowManifest;
+}
+/** The flow registry file structure */
+interface FlowRegistry {
+  /** Schema version */
+  version: 1;
+  /** Map of flow name → registry entry */
+  flows: Record<string, FlowRegistryEntry>;
+}
+/** Flow execution state */
+type FlowStatus = 'idle' | 'active' | 'completed';
+/** Active flow state (persisted to state.json) */
+interface FlowState {
+  /** Which flow is active (name from registry) */
+  flow: string;
+  /** Current status */
+  status: FlowStatus;
+  /** Current step ID (null if not started) */
+  currentStep: string | null;
+  /** Completed step IDs in order */
+  completedSteps: string[];
+  /** Skipped step IDs */
+  skippedSteps: string[];
+  /** Map of artifact name → file path */
+  artifacts: Record<string, string>;
+  /** ISO timestamp when flow was started */
+  startedAt: string;
+  /** ISO timestamp of last state change */
+  updatedAt: string;
+}
+/** Step action for state machine transitions */
+type StepAction = 'next' | 'skip' | 'redo';
+/** Format adapter interface — converts external formats to FlowManifest */
+interface FlowFormatAdapter {
+  /** Format name */
+  readonly format: FlowFormat;
+  /** Check if a directory matches this format */
+  detect(sourceDir: string): boolean;
+  /** Parse the source directory into a FlowManifest */
+  parse(sourceDir: string): Promise<FlowManifest>;
+}
+/** Result of a flow operation */
+interface FlowResult<T = void> {
+  success: boolean;
+  data?: T;
+  error?: string;
+}
+//#endregion
+export { FlowFormat, FlowFormatAdapter, FlowManifest, FlowRegistry, FlowRegistryEntry, FlowResult, FlowSourceType, FlowState, FlowStatus, FlowStep, StepAction };

package/packages/flows/dist/types.js

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

package/packages/indexer/dist/file-hasher.d.ts

@@ -0,0 +1,13 @@
+//#region packages/indexer/src/file-hasher.d.ts
+/**
+ * Generate a deterministic hash for a file's content.
+ * Used for incremental indexing -- skip files that haven't changed.
+ */
+declare function hashContent(content: string): string;
+/**
+ * Generate a deterministic ID for a knowledge record.
+ * Based on source path + chunk index to ensure idempotent upserts.
+ */
+declare function generateRecordId(sourcePath: string, chunkIndex: number): string;
+//#endregion
+export { generateRecordId, hashContent };

package/packages/indexer/dist/file-hasher.js

@@ -0,0 +1 @@
+import{createHash as e}from"node:crypto";function t(t){return e(`sha256`).update(t).digest(`hex`).slice(0,16)}function n(t,n){let r=`${t}:${n}`;return e(`sha256`).update(r).digest(`hex`).slice(0,16)}export{n as generateRecordId,t as hashContent};

package/packages/indexer/dist/filesystem-crawler.d.ts

@@ -0,0 +1,29 @@
+//#region packages/indexer/src/filesystem-crawler.d.ts
+interface CrawlResult {
+  /** File path relative to workspace root */
+  relativePath: string;
+  /** Absolute file path */
+  absolutePath: string;
+  /** File content */
+  content: string;
+  /** File extension (lowercase, with dot) */
+  extension: string;
+}
+interface CrawlOptions {
+  /** Glob patterns to exclude */
+  excludePatterns: string[];
+  /** Root directory to crawl */
+  rootDir: string;
+}
+/**
+ * Crawl a directory tree and yield files that should be indexed.
+ */
+declare class FilesystemCrawler {
+  /** Binary file extensions that should always be skipped */
+  private static readonly BINARY_EXTENSIONS;
+  crawl(options: CrawlOptions): Promise<CrawlResult[]>;
+  private walkDir;
+  private isExcluded;
+}
+//#endregion
+export { CrawlOptions, CrawlResult, FilesystemCrawler };

package/packages/indexer/dist/filesystem-crawler.js

@@ -0,0 +1 @@
+import{lstat as e,readFile as t,readdir as n,stat as r}from"node:fs/promises";import{extname as i,join as a,relative as o}from"node:path";import{AIKIT_PATHS as s,FILE_LIMITS as c,createLogger as l}from"../../core/dist/index.js";import{minimatch as u}from"minimatch";const d=l(`indexer`);var f=class l{static BINARY_EXTENSIONS=new Set(`.node,.so,.dylib,.dll,.wasm,.bin,.exe,.png,.jpg,.jpeg,.gif,.bmp,.ico,.webp,.svg,.mp3,.mp4,.wav,.avi,.mov,.flac,.zip,.gz,.tar,.bz2,.7z,.rar,.pdf,.doc,.docx,.xls,.xlsx,.ppt,.pptx,.ttf,.otf,.woff,.woff2,.eot,.pyc,.class,.o,.obj,.a,.lib`.split(`,`));async crawl(e){let t=[],n=new Set;return await this.walkDir(e.rootDir,e.rootDir,e.excludePatterns,t,n),t}async walkDir(u,f,p,m,h){let g;try{g=await n(u,{withFileTypes:!0})}catch(e){let t=e.code;(t===`EACCES`||t===`EPERM`)&&d.warn(`Permission denied, skipping directory`,{dir:u});return}for(let n of g){let d=a(u,n.name),g=o(f,d).replace(/\\/g,`/`);if(!this.isExcluded(g,p)){if(n.isDirectory()){if(n.name.startsWith(`.`)&&!(n.name===s.ai.slice(1)&&g.startsWith(s.ai)))continue;try{if((await e(d)).isSymbolicLink())continue}catch{continue}let t=d;if(h.has(t))continue;h.add(t),await this.walkDir(d,f,p,m,h)}else if(n.isFile()){let e=i(n.name).toLowerCase();if(l.BINARY_EXTENSIONS.has(e))continue;try{if((await r(d)).size>c.maxFileSizeBytes)continue;let n=await t(d,`utf-8`);if(n.includes(`\0`))continue;m.push({relativePath:g,absolutePath:d,content:n,extension:e})}catch{}}}}}isExcluded(e,t){return t.some(t=>u(e,t,{dot:!0}))}};export{f as FilesystemCrawler};

package/packages/indexer/dist/graph-extractor.d.ts

@@ -0,0 +1,18 @@
+import { GraphEdge, GraphNode } from "../../store/dist/index.js";
+
+//#region packages/indexer/src/graph-extractor.d.ts
+interface ExtractedGraph {
+  nodes: GraphNode[];
+  edges: GraphEdge[];
+}
+/**
+ * Extract graph nodes and edges from a single file's content.
+ * Produces:
+ * - One "module" node per file
+ * - Symbol nodes (function, class, interface, type, const, enum)
+ * - "defines" edges from module → symbol
+ * - "imports" edges from module → imported module
+ */
+declare function extractGraph(content: string, sourcePath: string): ExtractedGraph;
+//#endregion
+export { ExtractedGraph, extractGraph };

package/packages/indexer/dist/graph-extractor.js

@@ -0,0 +1 @@
+import{createHash as e}from"node:crypto";import{dirname as t,extname as n,join as r}from"node:path";const i=new Set([`.ts`,`.tsx`,`.js`,`.jsx`,`.mjs`,`.cjs`]),a=[{pattern:/^export\s+(?:async\s+)?function\s+(\w+)/gm,kind:`function`,exported:!0},{pattern:/^export\s+(?:default\s+)?class\s+(\w+)/gm,kind:`class`,exported:!0},{pattern:/^export\s+interface\s+(\w+)/gm,kind:`interface`,exported:!0},{pattern:/^export\s+type\s+(\w+)/gm,kind:`type`,exported:!0},{pattern:/^export\s+(?:const|let)\s+(\w+)/gm,kind:`const`,exported:!0},{pattern:/^export\s+enum\s+(\w+)/gm,kind:`enum`,exported:!0},{pattern:/^(?:async\s+)?function\s+(\w+)/gm,kind:`function`,exported:!1},{pattern:/^class\s+(\w+)/gm,kind:`class`,exported:!1},{pattern:/^interface\s+(\w+)/gm,kind:`interface`,exported:!1},{pattern:/^type\s+(\w+)/gm,kind:`type`,exported:!1},{pattern:/^enum\s+(\w+)/gm,kind:`enum`,exported:!1}],o=[/import\s+(?:(?:type\s+)?(?:(?:\{[^}]*\}|[\w*]+)\s+from\s+)?)['"]([^'"]+)['"]/g,/import\(\s*['"]([^'"]+)['"]\s*\)/g,/require\(\s*['"]([^'"]+)['"]\s*\)/g];function s(t,n,r){return e(`sha256`).update(`${t}:${n}:${r}`).digest(`hex`).slice(0,16)}function c(t,n,r){return e(`sha256`).update(`${t}-${r}-${n}`).digest(`hex`).slice(0,16)}function l(e,n){return r(t(n),e).replace(/\\/g,`/`).replace(/\.(js|jsx|ts|tsx|mjs|cjs)$/,``)}function u(e){return e.replace(/\.(js|jsx|ts|tsx|mjs|cjs)$/,``)}function d(e,t){let r=n(t).toLowerCase();if(!i.has(r))return{nodes:[],edges:[]};let d=[],f=[],p=new Date().toISOString(),m=new Set,h=u(t),g=s(`module`,h,h);d.push({id:g,type:`module`,name:t,properties:{ext:r},sourcePath:t,createdAt:p});for(let{pattern:n,kind:r,exported:i}of a){let a=new RegExp(n.source,n.flags),o;for(;(o=a.exec(e))!==null;){let e=o[1],n=`${r}:${e}`;if(m.has(n))continue;m.add(n);let a=s(r,e,t);d.push({id:a,type:r,name:e,properties:{exported:i},sourcePath:t,createdAt:p}),f.push({id:c(g,a,`defines`),fromId:g,toId:a,type:`defines`,weight:i?1:.5})}}let _=new Set;for(let n of o){let r=new RegExp(n.source,n.flags),i;for(;(i=r.exec(e))!==null;){let e=i[1];if(!e.startsWith(`.`)||_.has(e))continue;_.add(e);let n=l(e,t),r=s(`module`,n,n);f.push({id:c(g,r,`imports`),fromId:g,toId:r,type:`imports`,properties:{source:e}})}}return{nodes:d,edges:f}}export{d as extractGraph};

package/packages/indexer/dist/hash-cache.d.ts

@@ -0,0 +1,24 @@
+//#region packages/indexer/src/hash-cache.d.ts
+/**
+ * Persistent file hash cache.
+ * Stores path->hash mappings in a JSON file to avoid LanceDB round-trips
+ * when checking which files have changed during incremental indexing.
+ */
+declare class FileHashCache {
+  private cache;
+  private readonly filePath;
+  private dirty;
+  constructor(storeDir: string);
+  /** Load cache from disk. Non-fatal if missing or corrupt. */
+  load(): void;
+  get(path: string): string | undefined;
+  set(path: string, hash: string): void;
+  delete(path: string): void;
+  /** Persist cache to disk if changed. */
+  flush(): void;
+  /** Clear all entries and delete file. */
+  clear(): void;
+  get size(): number;
+}
+//#endregion
+export { FileHashCache };

package/packages/indexer/dist/hash-cache.js

@@ -0,0 +1 @@
+import{resolve as e}from"node:path";import{createLogger as t}from"../../core/dist/index.js";import{existsSync as n,readFileSync as r,writeFileSync as i}from"node:fs";const a=t(`hash-cache`);var o=class{cache;filePath;dirty=!1;constructor(t){this.filePath=e(t,`file-hashes.json`),this.cache=new Map}load(){if(n(this.filePath))try{let e=r(this.filePath,`utf-8`),t=JSON.parse(e);this.cache=new Map(Object.entries(t)),a.info(`Hash cache loaded`,{entries:this.cache.size})}catch(e){a.warn(`Hash cache load failed, starting fresh`,{err:e}),this.cache=new Map}}get(e){return this.cache.get(e)}set(e,t){this.cache.set(e,t),this.dirty=!0}delete(e){this.cache.delete(e)&&(this.dirty=!0)}flush(){if(this.dirty)try{let e={};for(let[t,n]of this.cache)e[t]=n;i(this.filePath,JSON.stringify(e),`utf-8`),this.dirty=!1}catch(e){a.warn(`Hash cache flush failed`,{err:e})}}clear(){this.cache.clear(),this.dirty=!0,this.flush()}get size(){return this.cache.size}};export{o as FileHashCache};