@bolloon/bolloon-agent 0.1.0

package/src/constraint-runtime/src/context.ts

@@ -0,0 +1,45 @@
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export interface PortContext {
+  sourceRoot: string;
+  testsRoot: string;
+  assetsRoot: string;
+  archiveRoot: string;
+  pythonFileCount: number;
+  testFileCount: number;
+  assetFileCount: number;
+  archiveAvailable: boolean;
+}
+
+export function buildPortContext(base?: string): PortContext {
+  const root = base || __dirname;
+  const srcRoot = path.join(root, 'src');
+  const testsRoot = path.join(root, 'tests');
+  const assetsRoot = path.join(root, 'assets');
+  const archiveRoot = path.join(root, 'archive');
+
+  return {
+    sourceRoot: srcRoot,
+    testsRoot: testsRoot,
+    assetsRoot: assetsRoot,
+    archiveRoot: archiveRoot,
+    pythonFileCount: 0,
+    testFileCount: 0,
+    assetFileCount: 0,
+    archiveAvailable: false,
+  };
+}
+
+export function renderContext(context: PortContext): string {
+  return [
+    `Source root: ${context.sourceRoot}`,
+    `Test root: ${context.testsRoot}`,
+    `Assets root: ${context.assetsRoot}`,
+    `Archive root: ${context.archiveRoot}`,
+    `Archive available: ${context.archiveAvailable}`,
+  ].join('\n');
+}

package/src/constraint-runtime/src/coordinator/index.ts

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('coordinator');
+
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'] as string;
+export const MODULE_COUNT = SNAPSHOT['module_count'] as number;
+export const SAMPLE_FILES = SNAPSHOT['sample_files'] as string[];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+
+export default {
+  ARCHIVE_NAME,
+  MODULE_COUNT,
+  PORTING_NOTE,
+  SAMPLE_FILES,
+};

package/src/constraint-runtime/src/cost_hook.ts

@@ -0,0 +1,6 @@
+import { CostTracker } from './cost_tracker.js';
+
+export function applyCostHook(tracker: CostTracker, label: string, units: number): CostTracker {
+  tracker.record(label, units);
+  return tracker;
+}

package/src/constraint-runtime/src/cost_tracker.ts

@@ -0,0 +1,9 @@
+export class CostTracker {
+  totalUnits: number = 0;
+  events: string[] = [];
+
+  record(label: string, units: number): void {
+    this.totalUnits += units;
+    this.events.push(`${label}:${units}`);
+  }
+}

package/src/constraint-runtime/src/deferred_init.ts

@@ -0,0 +1,18 @@
+export interface DeferredInitResult {
+  trusted: boolean;
+  pluginInit: boolean;
+  skillInit: boolean;
+  mcpPrefetch: boolean;
+  sessionHooks: boolean;
+}
+
+export function runDeferredInit(trusted: boolean): DeferredInitResult {
+  const enabled = Boolean(trusted);
+  return {
+    trusted,
+    pluginInit: enabled,
+    skillInit: enabled,
+    mcpPrefetch: enabled,
+    sessionHooks: enabled,
+  };
+}

package/src/constraint-runtime/src/direct_modes.ts

@@ -0,0 +1,13 @@
+export interface DirectModeReport {
+  mode: string;
+  target: string;
+  active: boolean;
+}
+
+export function runDirectConnect(target: string): DirectModeReport {
+  return { mode: 'direct-connect', target, active: true };
+}
+
+export function runDeepLink(target: string): DirectModeReport {
+  return { mode: 'deep-link', target, active: true };
+}

package/src/constraint-runtime/src/dynamic-tool-loader.ts

@@ -0,0 +1,115 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export interface ToolResult {
+  success: boolean;
+  data?: any;
+  error?: string;
+}
+
+export interface ToolExecutor {
+  loadAndExecute(modulePath: string, functionName: string, params: any): Promise<ToolResult>;
+}
+
+function resolveToolPath(sourceHint: string): string {
+  return path.join(__dirname, sourceHint);
+}
+
+function inferFunctionName(sourceHint: string): string {
+  const basename = path.basename(sourceHint, path.extname(sourceHint));
+  const nameMap: Record<string, string> = {
+    listMarkets: 'listMarkets',
+    getMarket: 'getMarket',
+    createOrder: 'createOrder',
+    cancelOrder: 'cancelOrder',
+    getOrders: 'getOrders',
+    createTransaction: 'createTransaction',
+    proposeTransaction: 'proposeTransaction',
+    confirmTransaction: 'confirmTransaction',
+    executeTransaction: 'executeTransaction',
+    getPendingTransactions: 'getPendingTransactions',
+    getBalance: 'getBalance',
+    deploySafe: 'deploySafe',
+    runCommand: 'runCommand',
+    listAdapters: 'listAdapters',
+    execAdapter: 'execAdapter',
+  };
+  return nameMap[basename] || basename;
+}
+
+export async function executeToolFromSnapshot(
+  sourceHint: string,
+  params: any
+): Promise<ToolResult> {
+  try {
+    const fullPath = resolveToolPath(sourceHint);
+    
+    if (!fs.existsSync(fullPath)) {
+      return {
+        success: false,
+        error: `Tool file not found: ${fullPath}`,
+      };
+    }
+
+    const module = await import(`file://${fullPath}?t=${Date.now()}`);
+    const functionName = inferFunctionName(sourceHint);
+
+    if (typeof module[functionName] !== 'function') {
+      return {
+        success: false,
+        error: `Function '${functionName}' not found in ${sourceHint}`,
+      };
+    }
+
+    const result = await module[functionName](params);
+
+    return {
+      success: true,
+      data: result,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+export class DynamicToolExecutor implements ToolExecutor {
+  async loadAndExecute(
+    modulePath: string,
+    functionName: string,
+    params: any
+  ): Promise<ToolResult> {
+    try {
+      const fullPath = resolveToolPath(modulePath);
+
+      if (!fs.existsSync(fullPath)) {
+        return { success: false, error: `Module not found: ${fullPath}` };
+      }
+
+      const module = await import(`file://${fullPath}?t=${Date.now()}`);
+
+      if (typeof module[functionName] !== 'function') {
+        return {
+          success: false,
+          error: `Function '${functionName}' not exported from ${modulePath}`,
+        };
+      }
+
+      const result = await module[functionName](params);
+      return { success: true, data: result };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+}
+
+export const defaultExecutor = new DynamicToolExecutor();

package/src/constraint-runtime/src/entrypoints/index.ts

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('entrypoints');
+
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'] as string;
+export const MODULE_COUNT = SNAPSHOT['module_count'] as number;
+export const SAMPLE_FILES = SNAPSHOT['sample_files'] as string[];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+
+export default {
+  ARCHIVE_NAME,
+  MODULE_COUNT,
+  PORTING_NOTE,
+  SAMPLE_FILES,
+};

package/src/constraint-runtime/src/execution_registry.ts

@@ -0,0 +1,41 @@
+import { PORTED_COMMANDS, executeCommand } from './commands.js';
+import { PORTED_TOOLS, executeTool } from './tools.js';
+
+export class MirroredCommand {
+  constructor(public name: string, public sourceHint: string) {}
+  execute(prompt: string): string {
+    return executeCommand(this.name, prompt).message;
+  }
+}
+
+export class MirroredTool {
+  constructor(public name: string, public sourceHint: string) {}
+  async execute(payload: string): Promise<string> {
+    const result = await executeTool(this.name, payload);
+    return result.message;
+  }
+}
+
+export class ExecutionRegistry {
+  constructor(
+    public commands: MirroredCommand[],
+    public tools: MirroredTool[]
+  ) {}
+
+  command(name: string): MirroredCommand | undefined {
+    const lowered = name.toLowerCase();
+    return this.commands.find(c => c.name.toLowerCase() === lowered);
+  }
+
+  tool(name: string): MirroredTool | undefined {
+    const lowered = name.toLowerCase();
+    return this.tools.find(t => t.name.toLowerCase() === lowered);
+  }
+}
+
+export function buildExecutionRegistry(): ExecutionRegistry {
+  return new ExecutionRegistry(
+    PORTED_COMMANDS.map(m => new MirroredCommand(m.name, m.sourceHint)),
+    PORTED_TOOLS.map(m => new MirroredTool(m.name, m.sourceHint))
+  );
+}

package/src/constraint-runtime/src/history.ts

@@ -0,0 +1,16 @@
+export interface HistoryEvent {
+  title: string;
+  detail: string;
+}
+
+export class HistoryLog {
+  events: HistoryEvent[] = [];
+
+  add(title: string, detail: string): void {
+    this.events.push({ title, detail });
+  }
+
+  asMarkdown(): string {
+    return ['# Session History', '', ...this.events.map(e => `- ${e.title}: ${e.detail}`)].join('\n');
+  }
+}

package/src/constraint-runtime/src/hooks/index.ts

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('hooks');
+
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'] as string;
+export const MODULE_COUNT = SNAPSHOT['module_count'] as number;
+export const SAMPLE_FILES = SNAPSHOT['sample_files'] as string[];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+
+export default {
+  ARCHIVE_NAME,
+  MODULE_COUNT,
+  PORTING_NOTE,
+  SAMPLE_FILES,
+};

package/src/constraint-runtime/src/index.ts

@@ -0,0 +1,28 @@
+export * from './constraint/index.js';
+export * from './thinking/index.js';
+export * from './agent/index.js';
+export * from './skills/index.js';
+export * from './runtime/index.js';
+
+export { ToolPermissionContext } from './constraint/permission.js';
+export { BudgetTracker } from './constraint/budget.js';
+export { DeepThinkingEngine, type ThinkResult, type ThinkStep } from './thinking/engine.js';
+export { AgentCoordinator, type SubTask, type AgentResult } from './agent/coordinator.js';
+export { SkillRegistry, type Skill } from './skills/skill-registry.js';
+export { Session, type RuntimeSession } from './runtime/session.js';
+export * from './models.js';
+export { HistoryLog, type HistoryEvent } from './history.js';
+export { TranscriptStore } from './transcript.js';
+export { CostTracker } from './cost_tracker.js';
+export { buildSetup, runSetup, type SetupReport, type WorkspaceSetup } from './setup.js';
+export { buildPortContext, type PortContext } from './context.js';
+export { buildCommandGraph } from './command_graph.js';
+export { buildBootstrapGraph } from './bootstrap_graph.js';
+export { runParityAudit, type ParityAuditResult } from './parity_audit.js';
+export { runRemoteMode, runSshMode, runTeleportMode, type RuntimeModeReport } from './remote_runtime.js';
+export { runDirectConnect, runDeepLink, type DirectModeReport } from './direct_modes.js';
+export { assembleToolPool, type ToolPool } from './tool_pool.js';
+export { saveSession, loadSession, type StoredSession } from './session_store.js';
+
+export const VERSION = '0.1.0';
+export const NAME = '@bolloon/constraint-runtime';

package/src/constraint-runtime/src/ink.ts

@@ -0,0 +1,4 @@
+export function renderMarkdownPanel(text: string): string {
+  const border = '='.repeat(40);
+  return `${border}\n${text}\n${border}`;
+}

package/src/constraint-runtime/src/keybindings/index.ts

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('keybindings');
+
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'] as string;
+export const MODULE_COUNT = SNAPSHOT['module_count'] as number;
+export const SAMPLE_FILES = SNAPSHOT['sample_files'] as string[];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+
+export default {
+  ARCHIVE_NAME,
+  MODULE_COUNT,
+  PORTING_NOTE,
+  SAMPLE_FILES,
+};

package/src/constraint-runtime/src/memdir/index.ts

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('memdir');
+
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'] as string;
+export const MODULE_COUNT = SNAPSHOT['module_count'] as number;
+export const SAMPLE_FILES = SNAPSHOT['sample_files'] as string[];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+
+export default {
+  ARCHIVE_NAME,
+  MODULE_COUNT,
+  PORTING_NOTE,
+  SAMPLE_FILES,
+};

package/src/constraint-runtime/src/migrations/index.ts

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('migrations');
+
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'] as string;
+export const MODULE_COUNT = SNAPSHOT['module_count'] as number;
+export const SAMPLE_FILES = SNAPSHOT['sample_files'] as string[];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+
+export default {
+  ARCHIVE_NAME,
+  MODULE_COUNT,
+  PORTING_NOTE,
+  SAMPLE_FILES,
+};

package/src/constraint-runtime/src/models.ts

@@ -0,0 +1,49 @@
+export interface PortingModule {
+  name: string;
+  responsibility: string;
+  sourceHint: string;
+  status: PortingStatus;
+  readonly _jsonName?: string;
+}
+
+export interface Subsystem {
+  name: string;
+  path: string;
+  fileCount: number;
+  notes: string;
+}
+
+export interface PermissionDenial {
+  toolName: string;
+  reason: string;
+}
+
+export interface UsageSummary {
+  inputTokens: number;
+  outputTokens: number;
+}
+
+export interface TurnResult {
+  prompt: string;
+  output: string;
+  matchedCommands: string[];
+  matchedTools: string[];
+  permissionDenials: PermissionDenial[];
+  usage: UsageSummary;
+  stopReason: string;
+}
+
+export interface RoutedMatch {
+  kind: 'command' | 'tool';
+  name: string;
+  sourceHint: string;
+  score: number;
+}
+
+export type PortingStatus = 'mirrored' | 'ported' | 'pending';
+
+export interface PortingBacklog {
+  title: string;
+  modules: PortingModule[];
+  summaryLines(): string[];
+}

package/src/constraint-runtime/src/moreright/index.ts

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('moreright');
+
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'] as string;
+export const MODULE_COUNT = SNAPSHOT['module_count'] as number;
+export const SAMPLE_FILES = SNAPSHOT['sample_files'] as string[];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+
+export default {
+  ARCHIVE_NAME,
+  MODULE_COUNT,
+  PORTING_NOTE,
+  SAMPLE_FILES,
+};

package/src/constraint-runtime/src/native_ts/index.ts

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('native_ts');
+
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'] as string;
+export const MODULE_COUNT = SNAPSHOT['module_count'] as number;
+export const SAMPLE_FILES = SNAPSHOT['sample_files'] as string[];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+
+export default {
+  ARCHIVE_NAME,
+  MODULE_COUNT,
+  PORTING_NOTE,
+  SAMPLE_FILES,
+};

package/src/constraint-runtime/src/output_styles/index.ts

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('outputstyles');
+
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'] as string;
+export const MODULE_COUNT = SNAPSHOT['module_count'] as number;
+export const SAMPLE_FILES = SNAPSHOT['sample_files'] as string[];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+
+export default {
+  ARCHIVE_NAME,
+  MODULE_COUNT,
+  PORTING_NOTE,
+  SAMPLE_FILES,
+};

package/src/constraint-runtime/src/parity_audit.ts

@@ -0,0 +1,23 @@
+export interface ParityAuditResult {
+  archivePresent: boolean;
+  rootFileCoverage: [number, number];
+  directoryCoverage: [number, number];
+  totalFileRatio: [number, number];
+  commandEntryRatio: [number, number];
+  toolEntryRatio: [number, number];
+  missingRootTargets: string[];
+  missingDirectoryTargets: string[];
+}
+
+export function runParityAudit(): ParityAuditResult {
+  return {
+    archivePresent: false,
+    rootFileCoverage: [0, 0],
+    directoryCoverage: [0, 0],
+    totalFileRatio: [0, 0],
+    commandEntryRatio: [0, 0],
+    toolEntryRatio: [0, 0],
+    missingRootTargets: [],
+    missingDirectoryTargets: [],
+  };
+}

package/src/constraint-runtime/src/plugins/index.ts

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('plugins');
+
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'] as string;
+export const MODULE_COUNT = SNAPSHOT['module_count'] as number;
+export const SAMPLE_FILES = SNAPSHOT['sample_files'] as string[];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+
+export default {
+  ARCHIVE_NAME,
+  MODULE_COUNT,
+  PORTING_NOTE,
+  SAMPLE_FILES,
+};

package/src/constraint-runtime/src/port_manifest.ts

@@ -0,0 +1,20 @@
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { Subsystem } from './models.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export interface PortManifest {
+  srcRoot: string;
+  totalPythonFiles: number;
+  topLevelModules: Subsystem[];
+}
+
+export function buildPortManifest(srcRoot?: string): PortManifest {
+  return {
+    srcRoot: srcRoot || __dirname,
+    totalPythonFiles: 0,
+    topLevelModules: [],
+  };
+}

package/src/constraint-runtime/src/prefetch.ts

@@ -0,0 +1,17 @@
+export interface PrefetchResult {
+  name: string;
+  started: boolean;
+  detail: string;
+}
+
+export function startMdmRawRead(): PrefetchResult {
+  return { name: 'mdm_raw_read', started: true, detail: 'Simulated MDM raw-read prefetch for workspace bootstrap' };
+}
+
+export function startKeychainPrefetch(): PrefetchResult {
+  return { name: 'keychain_prefetch', started: true, detail: 'Simulated keychain prefetch for trusted startup path' };
+}
+
+export function startProjectScan(root: string): PrefetchResult {
+  return { name: 'project_scan', started: true, detail: `Scanned project root ${root}` };
+}

package/src/constraint-runtime/src/query.ts

@@ -0,0 +1,7 @@
+export interface QueryRequest {
+  prompt: string;
+}
+
+export interface QueryResponse {
+  text: string;
+}

package/src/constraint-runtime/src/reference_data/archive_surface_snapshot.json

@@ -0,0 +1,63 @@
+{
+  "archive_root": "archive/claude_code_ts_snapshot/src",
+  "root_files": [
+    "QueryEngine.ts",
+    "Task.ts",
+    "Tool.ts",
+    "commands.ts",
+    "context.ts",
+    "cost-tracker.ts",
+    "costHook.ts",
+    "dialogLaunchers.tsx",
+    "history.ts",
+    "ink.ts",
+    "interactiveHelpers.tsx",
+    "main.tsx",
+    "projectOnboardingState.ts",
+    "query.ts",
+    "replLauncher.tsx",
+    "setup.ts",
+    "tasks.ts",
+    "tools.ts"
+  ],
+  "root_dirs": [
+    "assistant",
+    "bootstrap",
+    "bridge",
+    "buddy",
+    "cli",
+    "commands",
+    "components",
+    "constants",
+    "context",
+    "coordinator",
+    "entrypoints",
+    "hooks",
+    "ink",
+    "keybindings",
+    "memdir",
+    "migrations",
+    "moreright",
+    "native-ts",
+    "outputStyles",
+    "plugins",
+    "query",
+    "remote",
+    "schemas",
+    "screens",
+    "server",
+    "services",
+    "skills",
+    "state",
+    "tasks",
+    "tools",
+    "types",
+    "upstreamproxy",
+    "utils",
+    "vim",
+    "voice"
+  ],
+  "total_ts_like_files": 1902,
+  "command_entry_count": 207,
+  "tool_entry_count": 184
+}