skyloom 1.13.6 → 1.13.8

package/src/plugins/loader.ts

@@ -1,66 +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;
-  }
-}
+/**
+ * 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

@@ -1,8 +1,21 @@
 /**
- * Skill loader — registers all built-in skills from skill definition files.
+ * Skill loader — built-in skills plus user/project skill discovery.
+ *
+ * Discovery order (later registration wins, so project beats user beats
+ * built-in when names collide):
+ *   1. built-in:  config/skills/, assets/builtin_skills/
+ *   2. user:      ~/.claude/skills/  (Claude Code compatible — zero-copy
+ *                 migration), then ~/.skyloom/skills/  (native)
+ *   3. project:   <cwd>/.claude/skills/, then <cwd>/.sky/skills/
+ *
+ * All locations use the same folder layout as Claude Code:
+ *   <root>/<skill-name>/SKILL.md  (+ optional reference files / scripts)
+ * Frontmatter is Claude Code compatible (name / description /
+ * allowed-tools — tool names like `bash`/`read` are aliased to sky tools).
  */
 
 import * as fs from 'fs';
+import * as os from 'os';
 import * as path from 'path';
 import { SkillRegistry } from '../core/skill';
 import { getLogger } from '../core/logger';
@@ -15,32 +28,48 @@ const BUILTIN_SKILL_DIRS = [
   path.join(__dirname, '..', '..', 'assets', 'builtin_skills'),
 ];
 
+/** User/project skill roots, lowest precedence first. */
+export function dynamicSkillDirs(cwd: string = process.cwd()): string[] {
+  return [
+    path.join(os.homedir(), '.claude', 'skills'),
+    path.join(os.homedir(), '.skyloom', 'skills'),
+    path.join(cwd, '.claude', 'skills'),
+    path.join(cwd, '.sky', 'skills'),
+  ];
+}
+
+/**
+ * (Re)scan user/project skill folders. Cheap enough to call on demand —
+ * list_skills triggers it, so edits to SKILL.md files apply live without
+ * restarting the session.
+ */
+export function registerDynamicSkills(registry: SkillRegistry, cwd: string = process.cwd()): number {
+  let count = 0;
+  for (const dir of dynamicSkillDirs(cwd)) {
+    try {
+      count += registry.loadSkillFolders(dir).length;
+    } catch (e) {
+      log.warn('dynamic_skill_load_failed', { dir, error: String(e) });
+    }
+  }
+  return count;
+}
+
 /**
- * Register all available skills from built-in directories.
+ * Register all available skills: built-ins, then user/project overlays.
  */
 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 });
-        }
-      }
+      registry.loadSkillFolders(dir);
     } catch (e) {
       log.warn('skill_load_failed', { dir, error: String(e) });
     }
   }
 
+  registerDynamicSkills(registry);
+
   const count = registry.listNames().length;
   log.info('skills_loaded', { count });
 }

package/src/sql.js.d.ts

@@ -1,29 +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>;
-}
+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

@@ -20,16 +20,26 @@ export function registerBuiltinTools(registry: ToolRegistry): void {
 
   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.',
+    description: 'Read the contents of a file. Large files are paged: pass offset (1-based start line) and limit (line count) to read further sections; use grep to locate the right offset first.',
     parameters: [
       { name: 'path', type: 'string', description: 'Absolute or relative path to the file', required: true },
+      { name: 'offset', type: 'number', description: '1-based line number to start from (default 1)', required: false },
+      { name: 'limit', type: 'number', description: 'Max lines to return (default 800)', required: false },
     ],
     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}`;
+        const lines = fs.readFileSync(filePath, 'utf-8').split('\n');
+        const offset = Math.max(1, Number(params.offset) || 1);
+        const limit = Math.max(1, Math.min(Number(params.limit) || 800, 4000));
+        const slice = lines.slice(offset - 1, offset - 1 + limit);
+        const remaining = lines.length - (offset - 1 + slice.length);
+        const tail = remaining > 0
+          ? `\n…[还有 ${remaining} 行 — read_file(path, offset=${offset + slice.length}) 继续]`
+          : '';
+        const range = offset > 1 || remaining > 0 ? ` lines ${offset}-${offset + slice.length - 1}/${lines.length}` : '';
+        return `Successfully read ${filePath}${range}:\n${slice.join('\n')}${tail}`;
       } catch (e) {
         return `Error reading file: ${e}`;
       }