skyloom 1.16.1 → 1.17.0

package/src/core/diagnostics.ts

@@ -0,0 +1,178 @@
+/**
+ * Code diagnostics — the LSP capability that matters most to an agent: surface
+ * real type/lint errors (with line:col) so the model fixes root causes instead
+ * of guessing.
+ *
+ * Strategy, in order:
+ *   1. TS/JS  → the TypeScript compiler API, resolved from the user's workspace
+ *               node_modules (then sky's own). Real semantic diagnostics, no
+ *               language server to install.
+ *   2. other  → a configured external checker command (config.diagnostics map
+ *               of `ext -> "cmd {file}"`), output parsed for `file:line:col msg`.
+ *
+ * This is intentionally not a full LSP client (hover/goto/rename); it delivers
+ * the diagnostics that close the agent's edit→verify loop on a per-file basis.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import { getLogger } from './logger';
+
+const log = getLogger('diagnostics');
+
+export type Severity = 'error' | 'warning' | 'info';
+
+export interface Diagnostic {
+  line: number;      // 1-based
+  column: number;    // 1-based
+  severity: Severity;
+  message: string;
+  code?: string;
+  source?: string;   // 'ts' | external command name
+}
+
+const TS_EXTS = new Set(['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs']);
+
+/** Resolve the TypeScript module the way an LSP would: workspace first. */
+function loadTypescript(cwd: string): any | null {
+  const bases = [cwd, process.cwd(), __dirname];
+  for (const base of bases) {
+    try {
+      const p = require.resolve('typescript', { paths: [base] });
+      return require(p);
+    } catch { /* try next */ }
+  }
+  try { return require('typescript'); } catch { return null; }
+}
+
+function findNearest(file: string, name: string): string | null {
+  let dir = path.dirname(path.resolve(file));
+  for (let i = 0; i < 40; i++) {
+    const candidate = path.join(dir, name);
+    if (fs.existsSync(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+/** Semantic + syntactic diagnostics for one TS/JS file via the compiler API. */
+export function getTypeScriptDiagnostics(file: string, cwd: string = process.cwd()): Diagnostic[] | { unavailable: string } {
+  const ts = loadTypescript(cwd);
+  if (!ts) return { unavailable: 'typescript not installed in workspace or sky — cannot type-check.' };
+
+  const abs = path.resolve(file);
+  let options: any = { allowJs: true, checkJs: false, noEmit: true, skipLibCheck: true };
+  let fileNames: string[] = [abs];
+
+  const tsconfig = findNearest(abs, 'tsconfig.json');
+  if (tsconfig) {
+    try {
+      const read = ts.readConfigFile(tsconfig, ts.sys.readFile);
+      const parsed = ts.parseJsonConfigFileContent(read.config || {}, ts.sys, path.dirname(tsconfig));
+      options = { ...parsed.options, noEmit: true };
+      // Keep the project's file set so cross-file types resolve, but ensure our
+      // target is included.
+      fileNames = parsed.fileNames.includes(abs) ? parsed.fileNames : [...parsed.fileNames, abs];
+    } catch (e) {
+      log.warn('tsconfig_parse_failed', { tsconfig, error: String(e) });
+    }
+  }
+
+  let program: any;
+  try {
+    program = ts.createProgram(fileNames, options);
+  } catch (e) {
+    return { unavailable: `failed to build TypeScript program: ${e}` };
+  }
+  const source = program.getSourceFile(abs);
+  if (!source) return { unavailable: `file not part of the TypeScript program: ${abs}` };
+
+  const raw = [
+    ...program.getSyntacticDiagnostics(source),
+    ...program.getSemanticDiagnostics(source),
+  ];
+
+  const out: Diagnostic[] = [];
+  for (const d of raw) {
+    const message = ts.flattenDiagnosticMessageText(d.messageText, '\n');
+    let line = 1, column = 1;
+    if (d.file && typeof d.start === 'number') {
+      const pos = d.file.getLineAndCharacterOfPosition(d.start);
+      line = pos.line + 1;
+      column = pos.character + 1;
+    }
+    const severity: Severity = d.category === 1 ? 'error' : d.category === 0 ? 'warning' : 'info';
+    out.push({ line, column, severity, message, code: d.code ? `TS${d.code}` : undefined, source: 'ts' });
+  }
+  out.sort((a, b) => a.line - b.line || a.column - b.column);
+  return out;
+}
+
+/** Parse generic `path:line:col: message` style compiler/linter output. */
+export function parseDiagnosticOutput(output: string, source: string): Diagnostic[] {
+  const out: Diagnostic[] = [];
+  const re = /^(.*?):(\d+):(\d+):?\s*(error|warning|info)?:?\s*(.*)$/gim;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(output)) !== null) {
+    const sev = (m[4] || 'error').toLowerCase() as Severity;
+    out.push({
+      line: parseInt(m[2], 10) || 1,
+      column: parseInt(m[3], 10) || 1,
+      severity: sev === 'warning' || sev === 'info' ? sev : 'error',
+      message: (m[5] || '').trim(),
+      source,
+    });
+  }
+  return out;
+}
+
+/** Run a configured external checker for a non-TS file. */
+function getExternalDiagnostics(file: string, command: string): Diagnostic[] | { unavailable: string } {
+  const cmd = command.includes('{file}')
+    ? command.replace(/\{file\}/g, JSON.stringify(file))
+    : `${command} ${JSON.stringify(file)}`;
+  let output = '';
+  try {
+    output = execSync(cmd, { encoding: 'utf8', timeout: 60000, stdio: ['ignore', 'pipe', 'pipe'] });
+  } catch (e: any) {
+    // Linters exit non-zero when they find problems — that's the normal path.
+    output = `${e.stdout || ''}\n${e.stderr || ''}`;
+  }
+  return parseDiagnosticOutput(output, command.split(/\s+/)[0]);
+}
+
+/**
+ * Get diagnostics for a file. `config.diagnostics` is an optional map of
+ * `ext -> command` for non-TS languages (e.g. { py: "ruff check {file}" }).
+ */
+export function getDiagnostics(file: string, config?: any, cwd: string = process.cwd()): Diagnostic[] | { unavailable: string } {
+  const abs = path.resolve(file);
+  if (!fs.existsSync(abs)) return { unavailable: `file not found: ${abs}` };
+
+  const ext = path.extname(abs).toLowerCase();
+  const map = (config?.diagnostics || {}) as Record<string, string>;
+  const extKey = ext.replace(/^\./, '');
+
+  // Explicit user config wins.
+  if (map[extKey]) return getExternalDiagnostics(abs, map[extKey]);
+  if (TS_EXTS.has(ext)) return getTypeScriptDiagnostics(abs, cwd);
+
+  return { unavailable: `no diagnostics provider for '${ext}'. Configure one in config.yaml diagnostics: { ${extKey || 'ext'}: "<checker> {file}" }` };
+}
+
+export function formatDiagnostics(file: string, diags: Diagnostic[]): string {
+  if (diags.length === 0) return `✓ ${file} — no diagnostics (clean).`;
+  const errs = diags.filter(d => d.severity === 'error').length;
+  const warns = diags.filter(d => d.severity === 'warning').length;
+  const head = `${file} — ${errs} error${errs !== 1 ? 's' : ''}, ${warns} warning${warns !== 1 ? 's' : ''}:`;
+  const lines = diags.slice(0, 100).map(d => {
+    const mark = d.severity === 'error' ? '✗' : d.severity === 'warning' ? '⚠' : 'ℹ';
+    const code = d.code ? ` ${d.code}` : '';
+    return `  ${mark} ${d.line}:${d.column}${code} — ${d.message.replace(/\n/g, ' ')}`;
+  });
+  const more = diags.length > 100 ? `\n  …and ${diags.length - 100} more` : '';
+  return `${head}\n${lines.join('\n')}${more}`;
+}

package/src/core/diff.ts

@@ -0,0 +1,98 @@
+/**
+ * Minimal line-based unified diff for edit previews.
+ *
+ * Edits applied by edit_file are localized (a contiguous region changes), so a
+ * single trimmed hunk — common prefix/suffix removed, the differing middle
+ * shown with a few lines of context — is enough to let the model and the user
+ * see exactly what changed without diffing whole files line-by-line.
+ */
+
+export interface DiffOptions {
+  /** Lines of unchanged context around the change (default 3). */
+  context?: number;
+  /** Optional path shown in the diff header. */
+  path?: string;
+}
+
+export interface DiffStat {
+  added: number;
+  removed: number;
+}
+
+/** Result of rendering a diff: the text plus +/- line counts. */
+export interface DiffResult {
+  text: string;
+  stat: DiffStat;
+}
+
+function commonPrefixLen(a: string[], b: string[]): number {
+  const n = Math.min(a.length, b.length);
+  let i = 0;
+  while (i < n && a[i] === b[i]) i++;
+  return i;
+}
+
+function commonSuffixLen(a: string[], b: string[], skip: number): number {
+  const max = Math.min(a.length, b.length) - skip;
+  let i = 0;
+  while (i < max && a[a.length - 1 - i] === b[b.length - 1 - i]) i++;
+  return i;
+}
+
+/**
+ * Produce a compact unified diff between two strings. Returns the diff text and
+ * a +/- line stat. Identical inputs yield an empty diff (stat 0/0).
+ */
+export function unifiedDiff(oldStr: string, newStr: string, opts: DiffOptions = {}): DiffResult {
+  if (oldStr === newStr) return { text: '', stat: { added: 0, removed: 0 } };
+
+  const context = Math.max(0, opts.context ?? 3);
+  const oldLines = oldStr.split('\n');
+  const newLines = newStr.split('\n');
+
+  let pre = commonPrefixLen(oldLines, newLines);
+  const suf = commonSuffixLen(oldLines, newLines, pre);
+
+  // The changed region (exclusive of the common prefix/suffix).
+  const oldChanged = oldLines.slice(pre, oldLines.length - suf);
+  const newChanged = newLines.slice(pre, newLines.length - suf);
+
+  // Context window bounds.
+  const ctxStart = Math.max(0, pre - context);
+  const oldCtxAfterStart = oldLines.length - suf;
+  const newCtxAfterStart = newLines.length - suf;
+  const oldCtxAfter = oldLines.slice(oldCtxAfterStart, oldCtxAfterStart + context);
+  const leading = oldLines.slice(ctxStart, pre);
+
+  const lines: string[] = [];
+  if (opts.path) lines.push(`--- ${opts.path}`, `+++ ${opts.path}`);
+
+  // Hunk header (1-based line numbers).
+  const oldStart = ctxStart + 1;
+  const oldCount = leading.length + oldChanged.length + oldCtxAfter.length;
+  const newStart = ctxStart + 1;
+  const newCount = leading.length + newChanged.length + oldCtxAfter.length;
+  lines.push(`@@ -${oldStart},${oldCount} +${newStart},${newCount} @@`);
+
+  for (const l of leading) lines.push(` ${l}`);
+  for (const l of oldChanged) lines.push(`-${l}`);
+  for (const l of newChanged) lines.push(`+${l}`);
+  for (const l of oldCtxAfter) lines.push(` ${l}`);
+
+  return {
+    text: lines.join('\n'),
+    stat: { added: newChanged.length, removed: oldChanged.length },
+  };
+}
+
+/** Count non-overlapping occurrences of `needle` in `haystack`. */
+export function countOccurrences(haystack: string, needle: string): number {
+  if (!needle) return 0;
+  let count = 0;
+  let idx = haystack.indexOf(needle);
+  while (idx !== -1) {
+    count++;
+    idx = haystack.indexOf(needle, idx + needle.length);
+  }
+  return count;
+}

package/src/core/envcontext.ts

@@ -0,0 +1,79 @@
+/**
+ * Environment context snapshot — a small, model-visible block describing the
+ * runtime world (working directory, platform, git, Node, date), kept separate
+ * from conversation history. Mirrors Claude Code's <env> block so the agent
+ * grounds itself without having to probe with tools every turn.
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+export interface GitInfo {
+  repo: boolean;
+  branch?: string;
+}
+
+/**
+ * Cheap git detection: walk up for a `.git` (handles worktrees, where `.git`
+ * is a file pointing at the real gitdir), then read HEAD for the branch. No
+ * subprocess — just file reads.
+ */
+export function gitInfo(cwd: string = process.cwd()): GitInfo {
+  let dir = path.resolve(cwd);
+  for (let i = 0; i < 40; i++) {
+    const dotGit = path.join(dir, '.git');
+    if (fs.existsSync(dotGit)) {
+      let gitDir = dotGit;
+      try {
+        if (fs.statSync(dotGit).isFile()) {
+          const m = fs.readFileSync(dotGit, 'utf8').match(/gitdir:\s*(.+)/);
+          if (m) gitDir = path.resolve(dir, m[1].trim());
+        }
+      } catch { /* treat as repo without branch */ }
+      try {
+        const head = fs.readFileSync(path.join(gitDir, 'HEAD'), 'utf8').trim();
+        const ref = head.match(/ref:\s*refs\/heads\/(.+)/);
+        return { repo: true, branch: ref ? ref[1] : head.slice(0, 8) };
+      } catch {
+        return { repo: true };
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return { repo: false };
+}
+
+/**
+ * Build the environment block. `now` is injectable for deterministic tests.
+ */
+export function buildEnvBlock(opts?: { cwd?: string; lang?: string; now?: Date }): string {
+  const cwd = opts?.cwd || process.cwd();
+  const lang = opts?.lang || 'zh';
+  const now = opts?.now || new Date();
+  const git = gitInfo(cwd);
+  const date = now.toISOString().slice(0, 10);
+  const platform = `${process.platform} ${os.release()}`;
+  const gitLine = git.repo ? (git.branch ? `yes (branch: ${git.branch})` : 'yes') : 'no';
+
+  if (lang === 'en') {
+    return [
+      '## Environment',
+      `- Working directory: ${cwd}`,
+      `- Platform: ${platform}`,
+      `- Node: ${process.version}`,
+      `- Git repo: ${gitLine}`,
+      `- Date: ${date}`,
+    ].join('\n');
+  }
+  return [
+    '## 运行环境',
+    `- 工作目录: ${cwd}`,
+    `- 平台: ${platform}`,
+    `- Node: ${process.version}`,
+    `- Git 仓库: ${gitLine === 'no' ? '否' : gitLine.replace('yes', '是')}`,
+    `- 日期: ${date}`,
+  ].join('\n');
+}

package/src/core/factory.ts

@@ -23,6 +23,7 @@ export class SystemContext {
   workspacePath: string = '';
   mcp: any = null;
   mcpStatus: string[] = [];
+  plugins: any = null;
 
   constructor(opts: {
     config: ReturnType<typeof loadConfig>;
@@ -33,6 +34,7 @@ export class SystemContext {
     workspacePath?: string;
     mcp?: any;
     mcpStatus?: string[];
+    plugins?: any;
   }) {
     this.config = opts.config;
     this.bus = opts.bus;
@@ -42,9 +44,15 @@ export class SystemContext {
     this.workspacePath = opts.workspacePath || '';
     this.mcp = opts.mcp || null;
     this.mcpStatus = opts.mcpStatus || [];
+    this.plugins = opts.plugins || null;
   }
 
   async initAll(): Promise<void> {
+    // Plugin `init` hook — fires once after load, before agents come up.
+    if (this.plugins) {
+      try { await this.plugins.emit('init', { config: this.config }); }
+      catch (e) { log.warn('plugin_init_hook_failed', { error: String(e) }); }
+    }
     if (this.mcp) {
       try {
         this.mcpStatus = await this.mcp.connectAll();
@@ -61,6 +69,11 @@ export class SystemContext {
   }
 
   async closeAll(): Promise<void> {
+    // Terminate any background shell jobs started this session.
+    try {
+      const { getBackgroundManager } = require('./bgproc');
+      getBackgroundManager().killAll();
+    } catch { /* best-effort */ }
     for (const agent of this.agentMap.values()) {
       await agent.close();
     }
@@ -114,10 +127,11 @@ export function createSystemContext(): SystemContext {
     log.warn('skills_not_available', { error: String(e) });
   }
 
-  // Load plugins
+  // Load plugins (ordered hook lifecycle — see plugins/loader)
+  let pluginLoader: any = null;
   try {
     const { PluginLoader } = require('../plugins/loader');
-    const pluginLoader = new PluginLoader(baseToolRegistry);
+    pluginLoader = new PluginLoader(baseToolRegistry, config);
     const pluginConfig = (config as any).plugins;
     const pluginDirs = pluginConfig?.enabled ? (pluginConfig.directories || []) : [];
     pluginLoader.loadFromDirectories(pluginDirs);
@@ -195,6 +209,20 @@ export function createSystemContext(): SystemContext {
         log.warn('delegate_tool_not_available', { agent: name, error: String(e) });
       }
 
+      // Register the spawn_agent tool — isolated-context subagents (Task tool).
+      try {
+        const { createSpawnAgentTool } = require('../tools/spawn');
+        agentRegistry.register(createSpawnAgentTool({
+          config,
+          llm,
+          bus,
+          baseToolRegistry,
+          baseSkillRegistry,
+        }));
+      } catch (e) {
+        log.warn('spawn_tool_not_available', { agent: name, error: String(e) });
+      }
+
       // Register model self-service tools (list_models / set_my_model)
       try {
         const { createModelTools } = require('../tools/model_tool');
@@ -234,6 +262,7 @@ export function createSystemContext(): SystemContext {
     toolRegistry: baseToolRegistry,
     workspacePath,
     mcp: mcpManager,
+    plugins: pluginLoader,
   });
 }
 

package/src/core/sandbox.ts

@@ -44,7 +44,7 @@ function cleanup(dir: string): void {
 /* ═══════════════════════════════════════
    Pre-execution check
    ═══════════════════════════════════════ */
-function preflightCheck(command: string): string | null {
+export function preflightCheck(command: string): string | null {
   if (!command || !command.trim()) return "Empty command";
 
   const lower = command.toLowerCase().trim();

package/src/core/security.ts

@@ -137,20 +137,75 @@ export interface AuditEntry {
 /* ═══════════════════════════════════════
    Security context — per-session security state
    ═══════════════════════════════════════ */
+/**
+ * Permission modes (Claude Code parity):
+ *  - strict       deny every non-SAFE tool (read-only-ish lockdown)
+ *  - interactive  ask before every non-SAFE tool ("default")
+ *  - auto         allow LOW, ask MEDIUM/HIGH, deny CRITICAL
+ *  - acceptEdits  auto-accept file-edit tools, otherwise behave like auto
+ *  - bypass       allow everything except red-line patterns ("yolo")
+ */
+export type ApprovalMode = "auto" | "interactive" | "strict" | "acceptEdits" | "bypass";
+export type Decision = "allow" | "ask" | "deny";
+
+/** User-facing aliases → canonical permission mode (for /perm and config). */
+export const PERMISSION_MODE_ALIASES: Record<string, ApprovalMode> = {
+  default: "interactive",
+  interactive: "interactive",
+  ask: "interactive",
+  auto: "auto",
+  accept: "acceptEdits",
+  acceptedits: "acceptEdits",
+  edits: "acceptEdits",
+  strict: "strict",
+  readonly: "strict",
+  bypass: "bypass",
+  yolo: "bypass",
+};
+
+/** Tools that mutate the filesystem — the ones acceptEdits waves through. */
+const EDIT_TOOL_RE = /^(write_|edit_|append_|replace_|create_|make_|copy_|move_|delete_)/;
+export function isEditTool(toolName: string): boolean { return EDIT_TOOL_RE.test(toolName); }
+
+/**
+ * Pure permission decision (red-line is gated separately, before this). Keeps
+ * the ask/allow/deny semantics in one testable place across all modes.
+ */
+export function decideApproval(level: DangerLevel, mode: ApprovalMode, toolName: string): Decision {
+  if (level === DangerLevel.SAFE) return "allow";
+  switch (mode) {
+    case "bypass": return "allow";
+    case "strict": return "deny";
+    case "interactive": return "ask";
+    case "acceptEdits":
+      if (level === DangerLevel.CRITICAL) return "deny";
+      if (isEditTool(toolName)) return "allow";
+      return level <= DangerLevel.LOW ? "allow" : "ask";
+    case "auto":
+    default:
+      if (level <= DangerLevel.LOW) return "allow";
+      if (level === DangerLevel.CRITICAL) return "deny";
+      return "ask";
+  }
+}
+
 export class SecurityContext {
   public auditLog: AuditEntry[] = [];
   public deniedCount = 0;
   public autoApprovedCount = 0;
   public manualApprovedCount = 0;
-  public approvalMode: "auto" | "interactive" | "strict" = "auto";
+  public approvalMode: ApprovalMode = "auto";
 
   private approvalCallback: ((tool: string, args: Record<string, any>, level: DangerLevel) => Promise<boolean>) | null = null;
 
-  constructor(opts?: { mode?: "auto" | "interactive" | "strict"; onApprove?: (tool: string, args: Record<string, any>, level: DangerLevel) => Promise<boolean> }) {
+  constructor(opts?: { mode?: ApprovalMode; onApprove?: (tool: string, args: Record<string, any>, level: DangerLevel) => Promise<boolean> }) {
     if (opts?.mode) this.approvalMode = opts.mode;
     if (opts?.onApprove) this.approvalCallback = opts.onApprove;
   }
 
+  /** Switch the active permission mode at runtime. */
+  setMode(mode: ApprovalMode): void { this.approvalMode = mode; }
+
   /** Get the danger level for a tool. Defaults to SAFE for unknown tools. */
   getDangerLevel(toolName: string): DangerLevel {
     return TOOL_DANGER_MAP[toolName] ?? DangerLevel.SAFE;
@@ -180,27 +235,13 @@ export class SecurityContext {
       return [false, redline];
     }
 
-    // Safe — always allow
-    if (level === DangerLevel.SAFE) return [true, "safe"];
-
-    // Strict mode — deny all non-safe
-    if (this.approvalMode === "strict") {
-      return [false, `Strict mode: tool '${toolName}' (level ${level}) requires manual approval`];
-    }
-
-    // Auto mode — allow LOW, prompt for MEDIUM+, deny CRITICAL
-    if (this.approvalMode === "auto") {
-      if (level <= DangerLevel.LOW) return [true, "auto-low"];
-      if (level === DangerLevel.CRITICAL) return [false, `CRITICAL tool '${toolName}' requires explicit human approval`];
-      // MEDIUM/HIGH with auto mode => need callback
-      if (this.approvalCallback) {
-        const approved = await this.approvalCallback(toolName, args, level);
-        return [approved, approved ? "user-approved" : "user-denied"];
-      }
-      return [true, "auto-med"]; // no callback → auto-allow but log
+    const decision = decideApproval(level, this.approvalMode, toolName);
+    if (decision === "allow") return [true, level === DangerLevel.SAFE ? "safe" : `${this.approvalMode}-allow`];
+    if (decision === "deny") {
+      return [false, `${this.approvalMode} mode: tool '${toolName}' (level ${level}) requires approval / is blocked`];
     }
 
-    // Interactive mode — prompt for LOW+
+    // decision === "ask" — defer to the interactive callback if present.
     if (this.approvalCallback) {
       const approved = await this.approvalCallback(toolName, args, level);
       return [approved, approved ? "user-approved" : "user-denied"];

package/src/core/skill.ts

@@ -210,7 +210,7 @@ function parseFrontmatter(text: string): { fm: Record<string, any>; body: string
 /**
  * Normalize a Claude Code tool name into sky's registry name.
  */
-function normalizeClaudeToolName(raw: string): string {
+export function normalizeClaudeToolName(raw: string): string {
   let s = raw.trim();
   if (!s) return s;
   // Strip permission scoping: Bash(ls *) -> Bash