@bolloon/bolloon-agent 0.1.0

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

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('remote');
+
+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/remote_runtime.ts

@@ -0,0 +1,17 @@
+export interface RuntimeModeReport {
+  mode: string;
+  connected: boolean;
+  detail: string;
+}
+
+export function runRemoteMode(target: string): RuntimeModeReport {
+  return { mode: 'remote', connected: true, detail: `Remote control placeholder prepared for ${target}` };
+}
+
+export function runSshMode(target: string): RuntimeModeReport {
+  return { mode: 'ssh', connected: true, detail: `SSH proxy placeholder prepared for ${target}` };
+}
+
+export function runTeleportMode(target: string): RuntimeModeReport {
+  return { mode: 'teleport', connected: true, detail: `Teleport resume/create placeholder prepared for ${target}` };
+}

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

@@ -0,0 +1 @@
+export { Session, type RuntimeSession } from './session.js';

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

@@ -0,0 +1,42 @@
+import { ToolPermissionContext } from '../constraint/permission.js';
+import { BudgetTracker } from '../constraint/budget.js';
+
+export interface RuntimeSession {
+  sessionId: string;
+  messages: string[];
+  context: Record<string, unknown>;
+  turnCount: number;
+}
+
+export class Session implements RuntimeSession {
+  constructor(
+    public sessionId: string,
+    public messages: string[] = [],
+    public context: Record<string, unknown> = {},
+    public turnCount: number = 0,
+    public permissionContext: ToolPermissionContext = ToolPermissionContext.fromIterables(),
+    public budget: BudgetTracker = new BudgetTracker()
+  ) {}
+
+  addMessage(msg: string): void {
+    this.messages.push(msg);
+    this.turnCount++;
+  }
+
+  get history(): string[] {
+    return [...this.messages];
+  }
+
+  clear(): void {
+    this.messages = [];
+    this.turnCount = 0;
+  }
+
+  setContext(key: string, value: unknown): void {
+    this.context[key] = value;
+  }
+
+  getContext(key: string): unknown {
+    return this.context[key];
+  }
+}

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

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('schemas');
+
+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/screens/index.ts

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('screens');
+
+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/server/index.ts

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('server');
+
+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/services/index.ts

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('services');
+
+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/session_store.ts

@@ -0,0 +1,32 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface StoredSession {
+  sessionId: string;
+  messages: string[];
+  inputTokens: number;
+  outputTokens: number;
+}
+
+const SESSION_DIR = '.port_sessions';
+
+export function saveSession(session: StoredSession): string {
+  const targetDir = path.join(process.cwd(), SESSION_DIR);
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+  const filePath = path.join(targetDir, `${session.sessionId}.json`);
+  fs.writeFileSync(filePath, JSON.stringify(session, null, 2));
+  return filePath;
+}
+
+export function loadSession(sessionId: string): StoredSession {
+  const filePath = path.join(process.cwd(), SESSION_DIR, `${sessionId}.json`);
+  const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  return {
+    sessionId: data.sessionId,
+    messages: data.messages,
+    inputTokens: data.inputTokens,
+    outputTokens: data.outputTokens,
+  };
+}

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

@@ -0,0 +1,50 @@
+import * as platform from 'platform';
+import * as path from 'path';
+import { runDeferredInit, DeferredInitResult } from './deferred_init.js';
+import { startMdmRawRead, startKeychainPrefetch, startProjectScan, PrefetchResult } from './prefetch.js';
+
+export interface WorkspaceSetup {
+  pythonVersion: string;
+  implementation: string;
+  platformName: string;
+  testCommand: string;
+  startupSteps: string[];
+}
+
+export interface SetupReport {
+  setup: WorkspaceSetup;
+  prefetches: PrefetchResult[];
+  deferredInit: DeferredInitResult;
+  trusted: boolean;
+  cwd: string;
+}
+
+export function buildWorkspaceSetup(): WorkspaceSetup {
+  return {
+    pythonVersion: `${platform.version}`,
+    implementation: platform.name || 'unknown',
+    platformName: platform.os?.toString() || 'unknown',
+    testCommand: 'npm test',
+    startupSteps: [
+      'start top-level prefetch side effects',
+      'build workspace context',
+      'load mirrored command snapshot',
+      'load mirrored tool snapshot',
+      'prepare parity audit hooks',
+      'apply trust-gated deferred init',
+    ],
+  };
+}
+
+export function runSetup(cwd?: string, trusted: boolean = true): SetupReport {
+  const root = cwd || process.cwd();
+  return {
+    setup: buildWorkspaceSetup(),
+    prefetches: [startMdmRawRead(), startKeychainPrefetch(), startProjectScan(root)],
+    deferredInit: runDeferredInit(trusted),
+    trusted,
+    cwd: root,
+  };
+}
+
+export { buildWorkspaceSetup as buildSetup };

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

@@ -0,0 +1 @@
+export { SkillRegistry, type Skill } from './skill-registry.js';

package/src/constraint-runtime/src/skills/skill-registry.ts

@@ -0,0 +1,40 @@
+export interface Skill {
+  name: string;
+  description: string;
+  execute(params: Record<string, unknown>): Promise<string>;
+}
+
+export class SkillRegistry {
+  private skills: Map<string, Skill> = new Map();
+
+  register(skill: Skill): void {
+    if (this.skills.has(skill.name)) {
+      throw new Error(`Skill already registered: ${skill.name}`);
+    }
+    this.skills.set(skill.name, skill);
+  }
+
+  unregister(name: string): boolean {
+    return this.skills.delete(name);
+  }
+
+  get(name: string): Skill | undefined {
+    return this.skills.get(name);
+  }
+
+  list(): Skill[] {
+    return Array.from(this.skills.values());
+  }
+
+  has(name: string): boolean {
+    return this.skills.has(name);
+  }
+
+  async execute(name: string, params: Record<string, unknown>): Promise<string> {
+    const skill = this.skills.get(name);
+    if (!skill) {
+      throw new Error(`Skill not found: ${name}`);
+    }
+    return skill.execute(params);
+  }
+}

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

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('state');
+
+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/system_init.ts

@@ -0,0 +1,21 @@
+import { getCommands, builtInCommandNames } from './commands.js';
+import { getTools } from './tools.js';
+import { runSetup } from './setup.js';
+
+export function buildSystemInitMessage(trusted: boolean = true): string {
+  const setup = runSetup(undefined, trusted);
+  const commands = getCommands();
+  const tools = getTools();
+  const lines = [
+    '# System Init',
+    '',
+    `Trusted: ${setup.trusted}`,
+    `Built-in command names: ${builtInCommandNames().size}`,
+    `Loaded command entries: ${commands.length}`,
+    `Loaded tool entries: ${tools.length}`,
+    '',
+    'Startup steps:',
+    ...setup.setup.startupSteps.map(step => `- ${step}`),
+  ];
+  return lines.join('\n');
+}

package/src/constraint-runtime/src/thinking/engine.ts

@@ -0,0 +1,61 @@
+export interface ThinkStep {
+  step: number;
+  thought: string;
+  reflection?: string;
+  improvement?: string;
+}
+
+export interface ThinkResult {
+  originalPrompt: string;
+  steps: ThinkStep[];
+  finalOutput: string;
+  depth: number;
+}
+
+export class DeepThinkingEngine {
+  constructor(private maxDepth: number = 3) {}
+
+  async think(prompt: string): Promise<ThinkResult> {
+    const steps: ThinkStep[] = [];
+    let current = prompt;
+
+    for (let i = 0; i < this.maxDepth; i++) {
+      const thought = await this.generateThought(current, i);
+      const reflection = await this.reflect(thought, current, i);
+
+      steps.push({
+        step: i + 1,
+        thought,
+        reflection: reflection.question,
+        improvement: reflection.improvement
+      });
+
+      if (reflection.improvement) {
+        current = reflection.improvement;
+      }
+    }
+
+    return {
+      originalPrompt: prompt,
+      steps,
+      finalOutput: steps[steps.length - 1]?.improvement ?? current,
+      depth: this.maxDepth
+    };
+  }
+
+  private async generateThought(prompt: string, step: number): Promise<string> {
+    return `[Step ${step + 1}] Analysis of: ${prompt}`;
+  }
+
+  private async reflect(thought: string, original: string, step: number): Promise<{ question: string; improvement?: string }> {
+    const isLastStep = step === this.maxDepth - 1;
+    return {
+      question: `Review: Is "${thought}" comprehensive and accurate?`,
+      improvement: isLastStep ? undefined : `${thought} (refined)`
+    };
+  }
+
+  setDepth(depth: number): void {
+    this.maxDepth = Math.max(1, Math.min(depth, 10));
+  }
+}

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

@@ -0,0 +1 @@
+export { DeepThinkingEngine, type ThinkResult, type ThinkStep } from './engine.js';

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

@@ -0,0 +1,20 @@
+import { getTools, PortingModule } from './tools.js';
+import { ToolPermissionContext } from './constraint/permission.js';
+
+export interface ToolPool {
+  tools: PortingModule[];
+  simpleMode: boolean;
+  includeMcp: boolean;
+}
+
+export function assembleToolPool(
+  simpleMode: boolean = false,
+  includeMcp: boolean = true,
+  permissionContext?: ToolPermissionContext
+): ToolPool {
+  return {
+    tools: getTools(simpleMode),
+    simpleMode,
+    includeMcp,
+  };
+}

package/src/constraint-runtime/src/tools/OpenCLI/execAdapter.ts

@@ -0,0 +1,12 @@
+export interface ExecAdapterParams {
+  adapter: string;
+  params?: Record<string, any>;
+}
+
+export async function execAdapter(params: ExecAdapterParams): Promise<{ success: boolean; result: any; error?: string }> {
+  return {
+    success: false,
+    result: null,
+    error: `OpenCLI adapter '${params.adapter}' requires OpenCLI CLI to be installed and configured.`,
+  };
+}

package/src/constraint-runtime/src/tools/OpenCLI/listAdapters.ts

@@ -0,0 +1,12 @@
+export interface Adapter {
+  name: string;
+  description: string;
+}
+
+export async function listAdapters(): Promise<Adapter[]> {
+  return [
+    { name: 'twitter', description: 'Twitter/X adapter' },
+    { name: 'reddit', description: 'Reddit adapter' },
+    { name: 'bilibili', description: 'Bilibili adapter' },
+  ];
+}

package/src/constraint-runtime/src/tools/OpenCLI/runCommand.ts

@@ -0,0 +1,13 @@
+export interface RunCommandParams {
+  command: string;
+  adapter?: string;
+  timeout?: number;
+}
+
+export async function runCommand(params: RunCommandParams): Promise<{ success: boolean; output: string; error?: string }> {
+  return {
+    success: false,
+    output: '',
+    error: 'OpenCLI is a command-line tool and should be invoked via shell command: opencli <command>',
+  };
+}

package/src/constraint-runtime/src/tools/PolymarketSDK/cancelOrder.ts

@@ -0,0 +1,10 @@
+export interface CancelOrderParams {
+  orderId: string;
+}
+
+export async function cancelOrder(params: CancelOrderParams): Promise<{ success: boolean; message: string }> {
+  return {
+    success: false,
+    message: 'Polymarket order cancellation requires CLOB client with authentication. Use the Polymarket web interface to cancel orders.',
+  };
+}

package/src/constraint-runtime/src/tools/PolymarketSDK/createOrder.ts

@@ -0,0 +1,13 @@
+export interface CreateOrderParams {
+  marketId: string;
+  side: 'BUY' | 'SELL';
+  price: number;
+  size: number;
+}
+
+export async function createOrder(params: CreateOrderParams): Promise<{ success: boolean; message: string }> {
+  return {
+    success: false,
+    message: 'Polymarket order creation requires CLOB client with authentication. Use the Polymarket web interface to create orders.',
+  };
+}

package/src/constraint-runtime/src/tools/PolymarketSDK/getMarket.ts

@@ -0,0 +1,14 @@
+export interface Market {
+  id: string;
+  question: string;
+  slug: string;
+  volume: string;
+  active: boolean;
+  closed: boolean;
+}
+
+export async function getMarket(id: string): Promise<Market | null> {
+  const { listMarkets } = await import('polymarket-sdk').catch(() => ({ listMarkets: async () => [] }));
+  const markets = await listMarkets({ id });
+  return markets[0] ?? null;
+}

package/src/constraint-runtime/src/tools/PolymarketSDK/getOrders.ts

@@ -0,0 +1,10 @@
+export interface GetOrdersParams {
+  marketId?: string;
+}
+
+export async function getOrders(params: GetOrdersParams = {}): Promise<{ orders: any[]; message: string }> {
+  return {
+    orders: [],
+    message: 'Polymarket order retrieval requires CLOB client with authentication. Use the Polymarket web interface to view orders.',
+  };
+}

package/src/constraint-runtime/src/tools/PolymarketSDK/listMarkets.ts

@@ -0,0 +1,24 @@
+export interface ListMarketsParams {
+  limit?: number;
+  offset?: number;
+  order?: string;
+  ascending?: boolean;
+  closed?: boolean;
+}
+
+export interface Market {
+  id: string;
+  question: string;
+  conditionId: string;
+  slug: string;
+  volume: string;
+  active: boolean;
+  closed: boolean;
+  outcomes: string;
+  outcomePrices: string;
+}
+
+export async function listMarkets(params: ListMarketsParams = {}): Promise<Market[]> {
+  const { listMarkets: marketsFn } = await import('polymarket-sdk').catch(() => ({ listMarkets: async () => [] }));
+  return marketsFn(params);
+}

package/src/constraint-runtime/src/tools/SafeSDK/confirmTransaction.ts

@@ -0,0 +1,13 @@
+export interface ConfirmTransactionParams {
+  safeAddress: string;
+  safeTxHash: string;
+  signerAddress: string;
+  signature?: string;
+}
+
+export async function confirmTransaction(params: ConfirmTransactionParams): Promise<{ success: boolean; message: string }> {
+  return {
+    success: false,
+    message: 'Safe transaction confirmation requires protocol kit with signer configured.',
+  };
+}

package/src/constraint-runtime/src/tools/SafeSDK/createTransaction.ts

@@ -0,0 +1,23 @@
+export interface CreateTransactionParams {
+  safeAddress: string;
+  to: string;
+  value: string;
+  data: string;
+  operation?: number;
+}
+
+export interface SafeTransaction {
+  to: string;
+  value: string;
+  data: string;
+  operation: number;
+}
+
+export async function createTransaction(params: CreateTransactionParams): Promise<SafeTransaction> {
+  return {
+    to: params.to,
+    value: params.value,
+    data: params.data,
+    operation: params.operation ?? 0,
+  };
+}

package/src/constraint-runtime/src/tools/SafeSDK/deploySafe.ts

@@ -0,0 +1,12 @@
+export interface DeploySafeParams {
+  owners: string[];
+  threshold: number;
+  saltNonce?: number;
+}
+
+export async function deploySafe(params: DeploySafeParams): Promise<{ success: boolean; message: string; safeAddress?: string }> {
+  return {
+    success: false,
+    message: 'Safe deployment requires protocol kit with deployer wallet configured.',
+  };
+}

package/src/constraint-runtime/src/tools/SafeSDK/executeTransaction.ts

@@ -0,0 +1,12 @@
+export interface ExecuteTransactionParams {
+  safeAddress: string;
+  safeTransaction: any;
+  signerAddress: string;
+}
+
+export async function executeTransaction(params: ExecuteTransactionParams): Promise<{ success: boolean; message: string }> {
+  return {
+    success: false,
+    message: 'Safe transaction execution requires protocol kit with executor and signer configured.',
+  };
+}

package/src/constraint-runtime/src/tools/SafeSDK/getBalance.ts

@@ -0,0 +1,10 @@
+export interface GetBalanceParams {
+  safeAddress: string;
+}
+
+export async function getBalance(params: GetBalanceParams): Promise<{ balance: string; message: string }> {
+  return {
+    balance: '0',
+    message: 'Balance retrieval requires protocol kit with RPC provider configured.',
+  };
+}

package/src/constraint-runtime/src/tools/SafeSDK/getPendingTransactions.ts

@@ -0,0 +1,10 @@
+export interface GetPendingTransactionsParams {
+  safeAddress: string;
+}
+
+export async function getPendingTransactions(params: GetPendingTransactionsParams): Promise<{ transactions: any[]; message: string }> {
+  return {
+    transactions: [],
+    message: 'Pending transaction retrieval requires Safe API Kit with transaction service URL configured.',
+  };
+}

package/src/constraint-runtime/src/tools/SafeSDK/proposeTransaction.ts

@@ -0,0 +1,14 @@
+export interface ProposeTransactionParams {
+  safeAddress: string;
+  safeTransaction: any;
+  safeTxHash: string;
+  signerAddress: string;
+  origin?: string;
+}
+
+export async function proposeSafeTransaction(params: ProposeTransactionParams): Promise<{ success: boolean; message: string }> {
+  return {
+    success: false,
+    message: 'Safe transaction proposal requires Safe API Kit with transaction service URL configured.',
+  };
+}