boxsafe 1.0.0

package/tests/loadConfig.test.ts

@@ -0,0 +1,25 @@
+import assert from 'node:assert/strict';
+import { test } from './runAllTests';
+import path from 'node:path';
+import fs from 'node:fs';
+import { loadBoxSafeConfig } from '@core/config/loadConfig';
+
+test('loadBoxSafeConfig: falls back to defaults when file does not exist', async () => {
+  const res = loadBoxSafeConfig('/tmp/__boxsafe_config_does_not_exist__.json');
+  assert.equal(res.source.loaded, false);
+  assert.ok(res.config);
+});
+
+test('loadBoxSafeConfig: normalizes limits.loops from "infinity" to MAX_SAFE_INTEGER', async () => {
+  const tmpDir = fs.mkdtempSync(path.join('/tmp', 'cfg-'));
+  const cfgPath = path.join(tmpDir, 'boxsafe.config.json');
+  fs.writeFileSync(cfgPath, JSON.stringify({ limits: { loops: 'infinity' } }), 'utf-8');
+
+  try {
+    const res = loadBoxSafeConfig(cfgPath);
+    assert.equal(res.source.loaded, true);
+    assert.equal(res.config.limits?.loops, Number.MAX_SAFE_INTEGER);
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+});

package/tests/navigatorBoundary.test.ts

@@ -0,0 +1,17 @@
+import assert from 'node:assert/strict';
+import { test } from './runAllTests';
+import path from 'node:path';
+import fs from 'node:fs';
+import { createNavigator } from '@core/navigate';
+
+test('Navigator: blocks directory traversal outside workspace', async () => {
+  const tempDir = fs.mkdtempSync(path.join('/tmp', 'nav-boundary-'));
+  try {
+    const nav = createNavigator({ workspace: tempDir });
+    const res = await nav.readFile('../../../etc/passwd');
+    assert.equal(res.ok, false);
+    assert.ok(String((res as any).error).includes('outside workspace'));
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});

package/tests/ports.test.ts

@@ -0,0 +1,84 @@
+import assert from 'node:assert/strict';
+import { test } from './runAllTests';
+import type { 
+  ISystemConfigurationPort, 
+  IFileSystemPort, 
+  ISystemExecutionPort 
+} from '@core/ports';
+
+test('Ports: ISystemConfigurationPort interface exists', () => {
+  // This test ensures the port interface is properly defined
+  // We'll test the actual interface structure by checking if it has the expected methods
+  const portMethods = ['loadConfiguration', 'validateConfiguration'];
+  
+  // Test that we can import the type
+  type ConfigPort = ISystemConfigurationPort;
+  
+  // Test that the methods are expected (this will fail if interface changes)
+  const mockPort: Partial<ConfigPort> = {
+    loadConfiguration: async () => ({ config: {} as any, source: { path: '', loaded: false } }),
+    validateConfiguration: async () => ({ valid: true, errors: [], warnings: [] })
+  };
+  
+  assert.equal(typeof mockPort.loadConfiguration, 'function');
+  assert.equal(typeof mockPort.validateConfiguration, 'function');
+});
+
+test('Ports: IFileSystemPort interface exists', () => {
+  const portMethods = ['listDirectory', 'readFile', 'writeFile', 'createDirectory', 'delete', 'getMetadata'];
+  
+  type FsPort = IFileSystemPort;
+  
+  const mockPort: Partial<FsPort> = {
+    listDirectory: async () => ({ ok: true }),
+    readFile: async () => ({ ok: true }),
+    writeFile: async () => ({ ok: true }),
+    createDirectory: async () => ({ ok: true }),
+    delete: async () => ({ ok: true }),
+    getMetadata: async () => ({ ok: true })
+  };
+  
+  assert.equal(typeof mockPort.listDirectory, 'function');
+  assert.equal(typeof mockPort.readFile, 'function');
+  assert.equal(typeof mockPort.writeFile, 'function');
+  assert.equal(typeof mockPort.createDirectory, 'function');
+  assert.equal(typeof mockPort.delete, 'function');
+  assert.equal(typeof mockPort.getMetadata, 'function');
+});
+
+test('Ports: ISystemExecutionPort interface exists', () => {
+  type ExecPort = ISystemExecutionPort;
+  
+  const mockPort: Partial<ExecPort> = {
+    executeSegment: async () => ({}),
+    listSegments: () => ({})
+  };
+  
+  assert.equal(typeof mockPort.executeSegment, 'function');
+  assert.equal(typeof mockPort.listSegments, 'function');
+});
+
+test('Ports: ConfigurationResult type structure', () => {
+  // Test that the types are properly structured
+  const result = {
+    config: {},
+    source: { path: '/test', loaded: true }
+  };
+  
+  assert.ok(result.config);
+  assert.equal(result.source.path, '/test');
+  assert.equal(result.source.loaded, true);
+});
+
+test('Ports: ValidationResult type structure', () => {
+  const result = {
+    valid: true,
+    errors: [],
+    warnings: ['test warning']
+  };
+  
+  assert.equal(result.valid, true);
+  assert.ok(Array.isArray(result.errors));
+  assert.ok(Array.isArray(result.warnings));
+  assert.equal(result.warnings[0], 'test warning');
+});

package/tests/runAllTests.ts

@@ -0,0 +1,49 @@
+import assert from 'node:assert/strict';
+import { Logger } from '@util/logger';
+
+const logger = Logger.createModuleLogger('TestRunner');
+
+type TestFn = () => void | Promise<void>;
+
+const tests: Array<{ name: string; fn: TestFn }> = [];
+
+export function test(name: string, fn: TestFn) {
+  tests.push({ name, fn });
+}
+
+async function run() {
+  let passed = 0;
+  let failed = 0;
+
+  const files = [
+    './tests/ports.test.ts',
+    './tests/adapters.test.ts',
+    './tests/extractCode.test.ts',
+    './tests/toolCalls.test.ts',
+    './tests/integration.test.ts',
+    './tests/navigatorBoundary.test.ts',
+    './tests/waterfall.test.ts',
+    './tests/loadConfig.test.ts',
+  ];
+
+  for (const f of files) {
+    await import(new URL(f, `file://${process.cwd()}/`).toString());
+  }
+
+  for (const t of tests) {
+    try {
+      await t.fn();
+      passed++;
+      logger.info(`✓ ${t.name}`);
+    } catch (err: any) {
+      failed++;
+      logger.error(`✗ ${t.name}`);
+      logger.error(String(err?.stack ?? err));
+    }
+  }
+
+  logger.info(`\nResults: ${passed} passed, ${failed} failed`);
+  assert.equal(failed, 0);
+}
+
+run();

package/tests/toolCalls.test.ts

@@ -0,0 +1,149 @@
+import assert from 'node:assert/strict';
+import { test } from './runAllTests';
+import { parseToolCallsFromMarkdown } from '@/core/loop/toolCalls';
+
+test('parseToolCallsFromMarkdown: parses valid json-tool write operation', async () => {
+  const md = '```json-tool\n{"tool": "navigate", "params": {"op": "write", "path": "test.ts", "content": "console.log(\\"hello\\");"}}\n```';
+  const result = parseToolCallsFromMarkdown(md);
+  
+  assert.equal(result.ok, true);
+  assert.equal(result.calls.length, 1);
+  assert.equal(result.errors.length, 0);
+  
+  const call = result.calls[0];
+  if (!call) throw new Error('Call should be defined');
+  assert.equal(call.tool, 'navigate');
+  assert.equal(call.params.op, 'write');
+  assert.equal(call.params.path, 'test.ts');
+  assert.equal(call.params.content, 'console.log("hello");');
+});
+
+test('parseToolCallsFromMarkdown: handles incomplete json-tool write operation', async () => {
+  const md = '```json-tool\n{"tool": "navigate", "params": {"op": "write", "path": "test.ts"}}\n```';
+  const result = parseToolCallsFromMarkdown(md);
+  
+  assert.equal(result.ok, true);
+  assert.equal(result.calls.length, 0);
+  assert.equal(result.errors.length, 1);
+  
+  const error = result.errors[0];
+  if (!error) throw new Error('Error should be defined');
+  assert.equal(error.ok, false);
+  assert.match(error.error, /navigate\.op=write requires params\.content/);
+});
+
+test('parseToolCallsFromMarkdown: parses multiple json-tool blocks', async () => {
+  const md = `
+    \`\`\`json-tool
+    {"tool": "navigate", "params": {"op": "read", "path": "file.ts"}}
+    \`\`\`
+    
+    Some text here
+    
+    \`\`\`json-tool
+    {"tool": "navigate", "params": {"op": "write", "path": "out.ts", "content": "export const x = 1;"}}
+    \`\`\`
+  `;
+  
+  const result = parseToolCallsFromMarkdown(md);
+  
+  assert.equal(result.ok, true);
+  assert.equal(result.calls.length, 2);
+  assert.equal(result.errors.length, 0);
+  
+  const call1 = result.calls[0];
+  const call2 = result.calls[1];
+  if (!call1 || !call2) throw new Error('Calls should be defined');
+  
+  assert.equal(call1.params.op, 'read');
+  assert.equal(call2.params.op, 'write');
+});
+
+test('parseToolCallsFromMarkdown: ignores regular json blocks', async () => {
+  const md = `
+    \`\`\`json
+    {"tool": "navigate", "params": {"op": "write", "path": "test.ts", "content": "hello"}}
+    \`\`\`
+    
+    \`\`\`json-tool
+    {"tool": "navigate", "params": {"op": "read", "path": "file.ts"}}
+    \`\`\`
+  `;
+  
+  const result = parseToolCallsFromMarkdown(md);
+  
+  assert.equal(result.ok, true);
+  assert.equal(result.calls.length, 1);
+  const call = result.calls[0];
+  if (!call) throw new Error('Call should be defined');
+  assert.equal(call.params.op, 'read');
+});
+
+test('parseToolCallsFromMarkdown: handles invalid JSON', async () => {
+  const md = '```json-tool\n{"tool": "navigate", "params": {"op": "write", "path": "test.ts", "content": }\n```';
+  const result = parseToolCallsFromMarkdown(md);
+  
+  assert.equal(result.ok, true);
+  assert.equal(result.calls.length, 0);
+  assert.equal(result.errors.length, 1);
+  
+  const error = result.errors[0];
+  if (!error) throw new Error('Error should be defined');
+  assert.equal(error.ok, false);
+  assert.match(error.error, /invalid JSON/);
+});
+
+test('parseToolCallsFromMarkdown: handles empty markdown', async () => {
+  const md = '';
+  const result = parseToolCallsFromMarkdown(md);
+  
+  assert.equal(result.ok, true);
+  assert.equal(result.calls.length, 0);
+  assert.equal(result.errors.length, 0);
+});
+
+test('parseToolCallsFromMarkdown: handles markdown without json-tool blocks', async () => {
+  const md = `
+    # Some markdown
+    
+    \`\`\`ts
+    console.log("hello");
+    \`\`\`
+    
+    Some text here
+  `;
+  
+  const result = parseToolCallsFromMarkdown(md);
+  
+  assert.equal(result.ok, true);
+  assert.equal(result.calls.length, 0);
+  assert.equal(result.errors.length, 0);
+});
+
+test('parseToolCallsFromMarkdown: handles versionControl tool', async () => {
+  const md = '```json-tool\n{"tool": "versionControl", "params": {"autoPush": true}}\n```';
+  const result = parseToolCallsFromMarkdown(md);
+  
+  assert.equal(result.ok, true);
+  assert.equal(result.calls.length, 1);
+  assert.equal(result.errors.length, 0);
+  
+  const call = result.calls[0];
+  if (!call) throw new Error('Call should be defined');
+  assert.equal(call.tool, 'versionControl');
+  assert.equal((call.params as any).autoPush, true);
+});
+
+test('parseToolCallsFromMarkdown: handles malformed json-tool block', async () => {
+  const md = '```json-tool\nnot a json\n```';
+  const result = parseToolCallsFromMarkdown(md);
+  
+  assert.equal(result.ok, true);
+  assert.equal(result.calls.length, 0);
+  assert.equal(result.errors.length, 1);
+  
+  const error = result.errors[0];
+  if (!error) throw new Error('Error should be defined');
+  assert.equal(error.ok, false);
+  assert.match(error.error, /invalid JSON/);
+});

package/tests/waterfall.test.ts

@@ -0,0 +1,52 @@
+import assert from 'node:assert/strict';
+import { test } from './runAllTests';
+import { waterfall } from '@core/loop/waterfall';
+import fs from 'node:fs';
+import path from 'node:path';
+
+test('waterfall: fails critical on non-zero exit code', async () => {
+  const res = await waterfall({
+    exec: { exitCode: 1, stdout: '', stderr: '' },
+    artifacts: {},
+  });
+  assert.equal(res.ok, false);
+  assert.equal((res as any).layer, 'exit-code');
+});
+
+test('waterfall: passes with exitCode=0 and empty stderr (contracts disabled)', async () => {
+  const prev = process.env.SUCCESS_CONTRACTS;
+  process.env.SUCCESS_CONTRACTS = '';
+  try {
+    const res = await waterfall({
+      exec: { exitCode: 0, stdout: '', stderr: '' },
+      artifacts: {},
+    });
+    assert.equal(res.ok, true);
+    assert.ok(res.score >= 70);
+  } finally {
+    if (prev === undefined) delete process.env.SUCCESS_CONTRACTS;
+    else process.env.SUCCESS_CONTRACTS = prev;
+  }
+});
+
+test('waterfall: artifacts check fails when outputFile is empty', async () => {
+  const tmpDir = fs.mkdtempSync(path.join('/tmp', 'wf-'));
+  const out = path.join(tmpDir, 'out.txt');
+  fs.writeFileSync(out, '');
+
+  const prev = process.env.SUCCESS_CONTRACTS;
+  process.env.SUCCESS_CONTRACTS = '';
+  try {
+    const res = await waterfall({
+      exec: { exitCode: 0, stdout: '', stderr: '' },
+      artifacts: { outputFile: out },
+    });
+    // Artifacts layer is non-critical; score should still be computed.
+    assert.equal(res.ok, true);
+    assert.equal(res.breakdown.artifacts.passed, false);
+  } finally {
+    if (prev === undefined) delete process.env.SUCCESS_CONTRACTS;
+    else process.env.SUCCESS_CONTRACTS = prev;
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+});

package/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "target": "esnext",
+    "paths": {
+      "@/*": ["./*"],
+      "@core/*": ["./core/*"],
+      "@coreutil/*": ["./core/util/*"],
+      "@ai/*": ["./ai/*"],
+      "@memo/*": ["./memo/*"],
+      "@util/*": ["./util/*"],
+      "@adapters/*": ["./adapters/*"]
+    },
+    "allowJs": true,
+    "types": ["node"],
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "strict": true,
+    "jsx": "react-jsx",
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true
+  },
+  "include": ["**/*.ts", "output.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsup.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+  entry: [
+    'external/**/*.ts',
+    'core/**/*.ts',
+    'box/**/*.ts',
+    'util/**/*.ts',
+    'adapters/**/*.ts'
+  ],
+  format: ['cjs', 'esm'],
+  dts: true,
+  clean: true,
+  sourcemap: true,
+  minify: true,
+  outDir: 'dist',
+})

package/types.d.ts

@@ -0,0 +1,96 @@
+// Types aligned with BS.config.json
+
+export type Limit = number | "infinity";
+
+export interface ProjectConfig {
+  workspace?: string;
+  testDir?: string;
+  versionControl?: {
+    before?: boolean;
+    after?: boolean;
+    autoPush?: boolean;
+    generateNotes?: boolean;
+  };
+}
+
+export interface ModelPrimary {
+  provider: string;
+  name: string;
+}
+
+export interface ModelConfig {
+  primary?: ModelPrimary;
+  fallback?: unknown[];
+  endpoint?: string | null;
+  parameters?: Record<string, unknown>;
+}
+
+export interface SmartRotationConfig {
+  enabled?: boolean;
+  simple?: unknown[];
+  complex?: unknown[];
+}
+
+export interface TimeoutConfig {
+  enabled?: boolean;
+  duration?: string;
+  notify?: boolean;
+}
+
+export interface LimitsConfig {
+  tokens?: number;
+  loops?: Limit;
+  timeout?: TimeoutConfig;
+}
+
+export interface SandboxConfig {
+  enabled?: boolean;
+  engine?: string;
+  memory?: string;
+  cpu?: number;
+  network?: string;
+}
+
+export type CommandRun = string | [string, string[]];
+
+export interface CommandsConfig {
+  setup?: string | null;
+  run?: string | null;
+  test?: string | null;
+  timeoutMs?: number | null;
+}
+
+export interface InterfaceNotifications {
+  whatsapp?: boolean;
+  telegram?: boolean;
+  slack?: boolean;
+  email?: boolean;
+}
+
+export interface InterfaceConfig {
+  channel?: string;
+  prompt?: string | null;
+  notifications?: InterfaceNotifications;
+}
+
+export interface TeachConfig {
+  urls?: string[];
+  files?: string[];
+}
+
+export interface PathsConfig {
+  generatedMarkdown?: string;
+  artifactOutput?: string;
+}
+
+export interface BoxSafeConfig {
+  project?: ProjectConfig;
+  model?: ModelConfig;
+  smartRotation?: SmartRotationConfig;
+  limits?: LimitsConfig;
+  sandbox?: SandboxConfig;
+  commands?: CommandsConfig;
+  interface?: InterfaceConfig;
+  paths?: PathsConfig;
+  teach?: TeachConfig;
+}

package/util/ANSI.ts

@@ -0,0 +1,29 @@
+// Basic ANSI escape codes for terminal colors
+export enum ANSI {
+  Reset = "\x1b[0m",
+  Bold = "\x1b[1m",
+  Dim = "\x1b[2m",
+
+  // Foreground colors
+  Black = "\x1b[30m",
+  Red = "\x1b[31m",
+  Green = "\x1b[32m",
+  Yellow = "\x1b[33m",
+  Blue = "\x1b[34m",
+  Magenta = "\x1b[35m",
+  Cyan = "\x1b[36m",
+  White = "\x1b[37m",
+
+  // Bright foreground colors
+  Gray = "\x1b[90m",
+  RedBright = "\x1b[91m",
+  GreenBright = "\x1b[92m",
+  YellowBright = "\x1b[93m",
+  BlueBright = "\x1b[94m",
+  MagentaBright = "\x1b[95m",
+  CyanBright = "\x1b[96m",
+  WhiteBright = "\x1b[97m",
+
+  // Background colors
+  BgRed = "\x1b[41m",
+}