skyloom 1.4.0

package/src/core/workspace.ts

@@ -0,0 +1,150 @@
+/**
+ * Workspace auto-detection and lifecycle management.
+ *
+ * Rules:
+ * - First launch: auto-select best drive, create workspace/
+ * - Multi-drive: skip C:, pick drive with most free space
+ * - Single drive (C: only): use C:\\workspace
+ * - Unix: use ~/workspace
+ * - User can override via config workspace.path
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+const WORKSPACE_SUBDIRS = ['files', 'output', 'temp'];
+
+export interface DriveInfo {
+  letter: string;
+  path: string;
+  totalBytes: number;
+  freeBytes: number;
+}
+
+/**
+ * Enumerate fixed drives with free-space info.
+ */
+function getDriveList(): DriveInfo[] {
+  const drives: DriveInfo[] = [];
+
+  if (process.platform === 'win32') {
+    for (let i = 0; i < 26; i++) {
+      const letter = String.fromCharCode(65 + i); // A-Z
+      const root = `${letter}:\\`;
+      if (!fs.existsSync(root)) continue;
+      try {
+        const stat = fs.statfsSync(root);
+        drives.push({
+          letter,
+          path: root,
+          totalBytes: stat.blocks * stat.bsize,
+          freeBytes: stat.bfree * stat.bsize,
+        });
+      } catch {
+        try {
+          // Fallback: just mark it available
+          drives.push({
+            letter,
+            path: root,
+            totalBytes: 0,
+            freeBytes: 0,
+          });
+        } catch {
+          continue;
+        }
+      }
+    }
+  } else {
+    // Unix — treat / as the single candidate
+    try {
+      const stat = fs.statfsSync('/');
+      drives.push({
+        letter: '',
+        path: '/',
+        totalBytes: stat.blocks * stat.bsize,
+        freeBytes: stat.bfree * stat.bsize,
+      });
+    } catch {
+      // Ignore
+    }
+  }
+
+  return drives;
+}
+
+/**
+ * Pick the best drive for the workspace directory.
+ *
+ * - Windows with multiple drives: skip C:, pick drive with most free bytes.
+ * - Windows with only C: → C:\\workspace.
+ * - Unix → ~/workspace.
+ */
+export function detectBestWorkspaceRoot(): string {
+  const drives = getDriveList();
+
+  if (process.platform === 'win32') {
+    let candidates = drives.filter((d) => d.letter.toUpperCase() !== 'C');
+    if (candidates.length === 0) {
+      candidates = drives; // fallback to C:
+    }
+    // Sort by free space descending
+    candidates.sort((a, b) => b.freeBytes - a.freeBytes);
+    const best = candidates[0];
+    return path.join(best.path, 'workspace');
+  } else {
+    return path.join(os.homedir(), 'workspace');
+  }
+}
+
+/**
+ * Resolve workspace path from config.
+ *
+ * - "auto" → call detectBestWorkspaceRoot()
+ * - explicit path → expand ~ and return
+ */
+export function resolveWorkspacePath(configValue: string): string {
+  if (configValue.toLowerCase() === 'auto') {
+    return detectBestWorkspaceRoot();
+  }
+  return path.resolve(configValue.replace(/^~/, os.homedir()));
+}
+
+/**
+ * Create workspace directory tree on first use. Idempotent.
+ *
+ * Creates:
+ *   workspace/
+ *   ├── files/    # agent-generated files
+ *   ├── output/   # task results, exports
+ *   └── temp/     # scratch / ephemeral
+ *
+ * Returns the resolved workspace root path.
+ */
+export function initWorkspace(root: string): string {
+  fs.mkdirSync(root, { recursive: true });
+  for (const sub of WORKSPACE_SUBDIRS) {
+    fs.mkdirSync(path.join(root, sub), { recursive: true });
+  }
+  // Touch a .workspace marker so tools can identify it
+  const marker = path.join(root, '.workspace');
+  if (!fs.existsSync(marker)) {
+    fs.writeFileSync(marker, `# Skyloom workspace — created automatically\npath: ${root}\n`, 'utf-8');
+  }
+  return root;
+}
+
+/**
+ * Human-readable byte count (e.g. 128.5 GB).
+ */
+export function formatBytes(n: number): string {
+  const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+  let val = n;
+  for (const unit of units) {
+    if (Math.abs(val) < 1024.0) {
+      return `${val.toFixed(1)} ${unit}`;
+    }
+    val /= 1024.0;
+  }
+  return `${val.toFixed(1)} PB`;
+}

package/src/plugins/loader.ts

@@ -0,0 +1,66 @@
+/**
+ * Plugin loader — loads external plugins that register additional tools.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { ToolRegistry } from '../core/tool';
+import { getLogger } from '../core/logger';
+
+const log = getLogger('plugin-loader');
+
+export class PluginLoader {
+  private toolRegistry: ToolRegistry;
+
+  constructor(toolRegistry: ToolRegistry) {
+    this.toolRegistry = toolRegistry;
+  }
+
+  /**
+   * Load plugins from specified directories.
+   */
+  loadFromDirectories(directories: string[]): number {
+    let total = 0;
+    for (const dir of directories) {
+      total += this.loadDirectory(dir);
+    }
+    return total;
+  }
+
+  /**
+   * Load a single plugin directory.
+   */
+  private loadDirectory(dir: string): number {
+    if (!fs.existsSync(dir)) {
+      log.debug('plugin_dir_not_found', { dir });
+      return 0;
+    }
+
+    let count = 0;
+    try {
+      const entries = fs.readdirSync(dir);
+      for (const entry of entries) {
+        const pluginPath = path.join(dir, entry);
+        if (!fs.statSync(pluginPath).isDirectory()) continue;
+
+        const pluginFile = path.join(pluginPath, 'index.js');
+        if (!fs.existsSync(pluginFile)) continue;
+
+        try {
+          const plugin = require(pluginFile);
+          if (typeof plugin.register === 'function') {
+            plugin.register(this.toolRegistry);
+            count++;
+            log.info('plugin_loaded', { name: entry });
+          }
+        } catch (e) {
+          log.warn('plugin_load_failed', { name: entry, error: String(e) });
+        }
+      }
+    } catch (e) {
+      log.warn('plugin_dir_scan_failed', { dir, error: String(e) });
+    }
+
+    return count;
+  }
+}

package/src/skills/loader.ts

@@ -0,0 +1,46 @@
+/**
+ * Skill loader — registers all built-in skills from skill definition files.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { SkillRegistry } from '../core/skill';
+import { getLogger } from '../core/logger';
+
+const log = getLogger('skills-loader');
+
+// Built-in skill directories to scan
+const BUILTIN_SKILL_DIRS = [
+  path.join(__dirname, '..', '..', 'config', 'skills'),
+  path.join(__dirname, '..', '..', 'assets', 'builtin_skills'),
+];
+
+/**
+ * Register all available skills from built-in directories.
+ */
+export function registerAllSkills(registry: SkillRegistry): void {
+  for (const dir of BUILTIN_SKILL_DIRS) {
+    if (!fs.existsSync(dir)) continue;
+
+    try {
+      const entries = fs.readdirSync(dir);
+      for (const entry of entries) {
+        const skillDir = path.join(dir, entry);
+        if (!fs.statSync(skillDir).isDirectory()) continue;
+
+        const skillFile = path.join(skillDir, 'SKILL.md');
+        if (!fs.existsSync(skillFile)) continue;
+
+        const skill = registry.loadSkillsFromDirectory(skillDir);
+        if (skill.length > 0) {
+          log.debug('registered_skill', { name: entry, file: skillFile });
+        }
+      }
+    } catch (e) {
+      log.warn('skill_load_failed', { dir, error: String(e) });
+    }
+  }
+
+  const count = registry.listNames().length;
+  log.info('skills_loaded', { count });
+}

package/src/sql.js.d.ts

@@ -0,0 +1,29 @@
+declare module 'sql.js' {
+  interface SqlJsStatic {
+    Database: new (data?: ArrayLike<number> | Buffer | null) => Database;
+  }
+
+  interface QueryExecResult {
+    columns: string[];
+    values: any[][];
+  }
+
+  interface Statement {
+    bind(params?: any[]): boolean;
+    step(): boolean;
+    getAsObject(params?: object): Record<string, any>;
+    free(): boolean;
+  }
+
+  interface Database {
+    run(sql: string, params?: any[]): Database;
+    exec(sql: string): QueryExecResult[];
+    prepare(sql: string): Statement;
+    export(): Uint8Array;
+    close(): void;
+  }
+
+  export type { Database, SqlJsStatic, Statement };
+
+  export default function initSqlJs(opts?: any): Promise<SqlJsStatic>;
+}

package/src/tools/builtin.ts

@@ -0,0 +1,382 @@
+/**
+ * Built-in tool registration — registers all default tools.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import type { ToolRegistry } from '../core/tool';
+import { getLogger } from '../core/logger';
+import { registerComputerTools } from './computer';
+
+const log = getLogger('builtin-tools');
+
+/**
+ * Register all built-in tools into the given registry.
+ */
+export function registerBuiltinTools(registry: ToolRegistry): void {
+  // Register computer tools
+  registerComputerTools(registry);
+  // ── File Tools ──
+
+  registry.register({
+    name: 'read_file',
+    description: 'Read the contents of a file at the given path. Use this to inspect files, check file contents, or verify writes.',
+    parameters: [
+      { name: 'path', type: 'string', description: 'Absolute or relative path to the file', required: true },
+    ],
+    handler: async (params) => {
+      const filePath = path.resolve(params.path as string);
+      if (!fs.existsSync(filePath)) return `Error: File not found: ${filePath}`;
+      try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return `Successfully read ${filePath} (${content.length} chars):\n${content}`;
+      } catch (e) {
+        return `Error reading file: ${e}`;
+      }
+    },
+  });
+
+  registry.register({
+    name: 'write_file',
+    description: 'Write content to a file at the given path. Creates directories if needed.',
+    parameters: [
+      { name: 'path', type: 'string', description: 'Absolute or relative path to write to', required: true },
+      { name: 'content', type: 'string', description: 'Content to write to the file', required: true },
+    ],
+    handler: async (params) => {
+      const filePath = path.resolve(params.path as string);
+      try {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, params.content as string, 'utf-8');
+        return `Successfully wrote ${Buffer.byteLength(params.content as string, 'utf-8')} bytes to ${filePath}`;
+      } catch (e) {
+        return `Error writing file: ${e}`;
+      }
+    },
+  });
+
+  registry.register({
+    name: 'edit_file',
+    description: 'Edit a file by replacing old_text with new_text. Use this for targeted edits.',
+    parameters: [
+      { name: 'path', type: 'string', description: 'Path to the file to edit', required: true },
+      { name: 'old_text', type: 'string', description: 'Text to search for and replace', required: true },
+      { name: 'new_text', type: 'string', description: 'Text to replace with', required: true },
+    ],
+    handler: async (params) => {
+      const filePath = path.resolve(params.path as string);
+      if (!fs.existsSync(filePath)) return `Error: File not found: ${filePath}`;
+      try {
+        let content = fs.readFileSync(filePath, 'utf-8');
+        const oldText = params.old_text as string;
+        const newText = params.new_text as string;
+        if (!content.includes(oldText)) {
+          return `Error: old_text not found in file. Searched for: ${oldText.slice(0, 50)}...`;
+        }
+        content = content.replace(oldText, newText);
+        fs.writeFileSync(filePath, content, 'utf-8');
+        return `Successfully edited ${filePath}`;
+      } catch (e) {
+        return `Error editing file: ${e}`;
+      }
+    },
+  });
+
+  registry.register({
+    name: 'delete_file',
+    description: 'Delete a file at the given path.',
+    parameters: [
+      { name: 'path', type: 'string', description: 'Path to the file to delete', required: true },
+    ],
+    handler: async (params) => {
+      const filePath = path.resolve(params.path as string);
+      if (!fs.existsSync(filePath)) return `Error: File not found: ${filePath}`;
+      try {
+        fs.unlinkSync(filePath);
+        return `Successfully deleted ${filePath}`;
+      } catch (e) {
+        return `Error deleting file: ${e}`;
+      }
+    },
+  });
+
+  registry.register({
+    name: 'list_directory',
+    description: 'List files and directories at the given path.',
+    parameters: [
+      { name: 'path', type: 'string', description: 'Path to list', required: true },
+    ],
+    handler: async (params) => {
+      const dirPath = path.resolve(params.path as string);
+      if (!fs.existsSync(dirPath)) return `Error: Directory not found: ${dirPath}`;
+      try {
+        const entries = fs.readdirSync(dirPath);
+        return entries.map(e => {
+          const stat = fs.statSync(path.join(dirPath, e));
+          return `${stat.isDirectory() ? '[DIR]' : '[FILE]'} ${e}`;
+        }).join('\n');
+      } catch (e) {
+        return `Error listing directory: ${e}`;
+      }
+    },
+  });
+
+  registry.register({
+    name: 'file_search',
+    description: 'Search for files matching a glob pattern.',
+    parameters: [
+      { name: 'pattern', type: 'string', description: 'Glob pattern to match (e.g. "**/*.ts")', required: true },
+      { name: 'directory', type: 'string', description: 'Directory to search in (default: cwd)', required: false },
+    ],
+    handler: async (params) => {
+      const dir = params.directory ? path.resolve(params.directory as string) : process.cwd();
+      const pattern = params.pattern as string;
+      try {
+        const { globSync } = require('glob');
+        const results = globSync(pattern, { cwd: dir, nodir: true });
+        if (results.length === 0) return 'No files found matching the pattern.';
+        return results.slice(0, 200).join('\n') + (results.length > 200 ? `\n... and ${results.length - 200} more` : '');
+      } catch (e) {
+        return `Error searching files: ${e}`;
+      }
+    },
+  });
+
+  // ── Shell Tool ──
+
+  registry.register({
+    name: 'run_bash',
+    description: 'Execute a shell command and return its output.',
+    parameters: [
+      { name: 'command', type: 'string', description: 'Command to execute', required: true },
+      { name: 'timeout', type: 'number', description: 'Timeout in milliseconds (default: 30000)', required: false },
+    ],
+    handler: async (params) => {
+      const { execSync } = require('child_process');
+      const cmd = params.command as string;
+      const timeout = (params.timeout as number) || 30000;
+      try {
+        const result = execSync(cmd, { encoding: 'utf-8', timeout, maxBuffer: 10 * 1024 * 1024 });
+        return result || '(command produced no output)';
+      } catch (e: any) {
+        return `Error: ${e.message || e}`;
+      }
+    },
+    dangerous: true,
+  });
+
+  // ── HTTP Tools ──
+
+  registry.register({
+    name: 'http_get',
+    description: 'Make an HTTP GET request to a URL.',
+    parameters: [
+      { name: 'url', type: 'string', description: 'URL to fetch', required: true },
+    ],
+    handler: async (params) => {
+      try {
+        const response = await fetch(params.url as string);
+        const text = await response.text();
+        return `Status: ${response.status}\n\n${text.slice(0, 10000)}${text.length > 10000 ? '\n...[truncated]' : ''}`;
+      } catch (e) {
+        return `Error fetching URL: ${e}`;
+      }
+    },
+  });
+
+  // ── Task Management ──
+
+  registry.register({
+    name: 'task_done',
+    description: 'Signal that the current task is complete and provide a summary. Call this when you have finished the work.',
+    parameters: [
+      { name: 'summary', type: 'string', description: 'Summary of what was accomplished', required: false },
+    ],
+    handler: async (_params) => {
+      return '__TASK_DONE__';
+    },
+    cacheable: false,
+  });
+
+  // ── Search Tool ──
+
+  registry.register({
+    name: 'web_search',
+    description: 'Search the web for information. Returns search results with titles and snippets.',
+    parameters: [
+      { name: 'query', type: 'string', description: 'Search query', required: true },
+    ],
+    handler: async (params) => {
+      // Simplified web search using a basic approach
+      try {
+        const query = encodeURIComponent(params.query as string);
+        const url = `https://api.duckduckgo.com/?q=${query}&format=json`;
+        const response = await fetch(url);
+        const data = await response.json() as Record<string, any>;
+        const results: string[] = [];
+        if (data.AbstractText) results.push(`Abstract: ${data.AbstractText}`);
+        if (data.RelatedTopics) {
+          for (const topic of data.RelatedTopics.slice(0, 10)) {
+            if (topic.Text) results.push(`- ${topic.Text}`);
+            else if (topic.Topics) {
+              for (const sub of topic.Topics.slice(0, 5)) {
+                if (sub.Text) results.push(`- ${sub.Text}`);
+              }
+            }
+          }
+        }
+        return results.length > 0 ? results.join('\n') : 'No search results found.';
+      } catch (e) {
+        return `Search error: ${e}`;
+      }
+    },
+  });
+
+  // ── Memory Tools ──
+
+  registry.register({
+    name: 'remember_fact',
+    description: 'Store a fact about the user or project in long-term memory.',
+    parameters: [
+      { name: 'key', type: 'string', description: 'Fact key (snake_case)', required: true },
+      { name: 'value', type: 'string', description: 'Fact value', required: true },
+      { name: 'category', type: 'string', description: 'Category (e.g. user_pref, project_info)', required: false },
+    ],
+    handler: async (_params) => {
+      return 'Fact stored. (Memory integration at agent level.)';
+    },
+  });
+
+  registry.register({
+    name: 'recall_facts',
+    description: 'Recall stored facts from long-term memory.',
+    parameters: [
+      { name: 'query', type: 'string', description: 'Search query to match against stored facts', required: true },
+    ],
+    handler: async (_params) => {
+      return 'Recall handled at agent level.';
+    },
+  });
+
+  // ── Git Tools ──
+
+  registry.register({
+    name: 'git_status',
+    description: 'Show the working tree status.',
+    parameters: [],
+    handler: async () => {
+      const { execSync } = require('child_process');
+      try {
+        return execSync('git status', { encoding: 'utf-8' });
+      } catch (e: any) {
+        return `Error: ${e.message || e}`;
+      }
+    },
+  });
+
+  registry.register({
+    name: 'git_diff',
+    description: 'Show changes between commits, commit and working tree, etc.',
+    parameters: [
+      { name: 'staged', type: 'boolean', description: 'Show staged changes only', required: false },
+    ],
+    handler: async (params) => {
+      const { execSync } = require('child_process');
+      try {
+        const args = params.staged ? '--staged' : '';
+        return execSync(`git diff ${args}`, { encoding: 'utf-8' });
+      } catch (e: any) {
+        return `Error: ${e.message || e}`;
+      }
+    },
+  });
+
+  registry.register({
+    name: 'git_log',
+    description: 'Show commit logs.',
+    parameters: [
+      { name: 'max_count', type: 'number', description: 'Number of commits to show (default: 10)', required: false },
+    ],
+    handler: async (params) => {
+      const { execSync } = require('child_process');
+      try {
+        const n = (params.max_count as number) || 10;
+        return execSync(`git log --oneline -${n}`, { encoding: 'utf-8' });
+      } catch (e: any) {
+        return `Error: ${e.message || e}`;
+      }
+    },
+  });
+
+  registry.register({
+    name: 'git_commit',
+    description: 'Create a new commit with the given message.',
+    parameters: [
+      { name: 'message', type: 'string', description: 'Commit message', required: true },
+    ],
+    handler: async (params) => {
+      const { execSync } = require('child_process');
+      try {
+        const msg = params.message as string;
+        execSync(`git commit -m "${msg.replace(/"/g, '\\"')}"`, { encoding: 'utf-8' });
+        return 'Commit created successfully.';
+      } catch (e: any) {
+        return `Error: ${e.message || e}`;
+      }
+    },
+    dangerous: true,
+  });
+
+  // ── Utility Tools ──
+
+  registry.register({
+    name: 'grep',
+    description: 'Search for a pattern in files using ripgrep or grep.',
+    parameters: [
+      { name: 'pattern', type: 'string', description: 'Regex pattern to search for', required: true },
+      { name: 'path', type: 'string', description: 'Directory to search in', required: false },
+    ],
+    handler: async (params) => {
+      const { execSync } = require('child_process');
+      const searchDir = params.path ? path.resolve(params.path as string) : process.cwd();
+      const pat = String(params.pattern || '');
+      try {
+        const out = execSync('rg -n ' + pat + ' ' + searchDir + ' 2>/dev/null || grep -rn ' + pat + ' ' + searchDir + ' 2>/dev/null || echo "No matches found"', { encoding: 'utf-8', maxBuffer: 1024 * 1024 });
+        return out;
+      } catch {
+        return 'No matches found.';
+      }
+    },
+  });
+
+  registry.register({
+    name: 'tree',
+    description: 'Display directory tree structure.',
+    parameters: [
+      { name: 'directory', type: 'string', description: 'Directory to show tree for', required: false },
+      { name: 'depth', type: 'number', description: 'Maximum depth (default: 3)', required: false },
+    ],
+    handler: async (params) => {
+      const { execSync } = require('child_process');
+      const treeDir = params.directory ? path.resolve(params.directory as string) : process.cwd();
+      const depth = (params.depth as number) || 3;
+      try {
+        const out = execSync('tree "' + treeDir + '" -L ' + depth + ' --charset=utf-8 2>/dev/null || echo "tree unavailable"', { encoding: 'utf-8' });
+        return out;
+      } catch {
+        return 'Directory tree unavailable.';
+      }
+    },
+  });
+
+  log.info('builtin_tools_registered', { count: registry.listNames().length });
+}
+
+let _httpClient: any = null;
+
+export async function closeHttpClient(): Promise<void> {
+  if (_httpClient) {
+    try { await _httpClient.close?.(); } catch { /* ignore */ }
+    _httpClient = null;
+  }
+}