skyloom 1.13.6 → 1.13.8

package/src/core/vector.ts

@@ -1,152 +1,152 @@
-/**
- * 向量语义搜索 — TF-IDF + Cosine similarity, zero dependencies.
- *
- * Replaces n-gram Jaccard as the default semantic scorer.
- * - IDF pre-computed from document corpus
- * - Cosine similarity on TF-IDF vectors
- * - CJK-aware tokenization (bigram for CJK, whitespace for ASCII)
- *
- * Usage:
- *   const idx = new VectorIndex();
- *   idx.addDocuments(docs);
- *   const results = idx.search("deploy script", 5);
- */
-
-/* ═══════════════════════════════════════
-   Tokenizer — CJK-aware
-   ═══════════════════════════════════════ */
-const CJK = /[一-鿿぀-ゟ가-힯]/;
-
-function tokenize(text: string): string[] {
-  const tokens: string[] = [];
-  let i = 0;
-  while (i < text.length) {
-    if (CJK.test(text[i])) {
-      if (i + 1 < text.length && CJK.test(text[i + 1])) {
-        tokens.push(text.slice(i, i + 2)); i += 2;
-      } else {
-        tokens.push(text[i]); i++;
-      }
-    } else if (/[A-Za-z0-9_]/.test(text[i])) {
-      let j = i;
-      while (j < text.length && /[A-Za-z0-9_]/.test(text[j])) j++;
-      tokens.push(text.slice(i, j).toLowerCase()); i = j;
-    } else {
-      i++;
-    }
-  }
-  return tokens;
-}
-
-/* ═══════════════════════════════════════
-   TF-IDF Vector computation
-   ═══════════════════════════════════════ */
-interface DocVector {
-  id: string;
-  tf: Map<string, number>;
-  norm: number;
-  content: string;
-  meta?: Record<string, any>;
-}
-
-export class VectorIndex {
-  private docs: DocVector[] = [];
-  private idf: Map<string, number> = new Map();
-  private totalDocs = 0;
-
-  /** Add a document to the index. */
-  addDocument(id: string, content: string, meta?: Record<string, any>): void {
-    const tokens = tokenize(content);
-    const tf = new Map<string, number>();
-    for (const t of tokens) { tf.set(t, (tf.get(t) || 0) + 1); }
-
-    // Normalize by doc length
-    const tfIdf = new Map<string, number>();
-    let normSq = 0;
-    for (const [term, freq] of tf) {
-      const tfVal = freq / tokens.length;
-      const idfVal = this.idf.get(term) || 0;
-      const val = tfVal * Math.max(0.1, idfVal);
-      tfIdf.set(term, val);
-      normSq += val * val;
-    }
-
-    const norm = Math.sqrt(normSq);
-    this.docs.push({ id, tf: tfIdf, norm, content: content.slice(0, 500), meta });
-    this.totalDocs++;
-
-    // Update IDF
-    for (const term of tf.keys()) {
-      this.idf.set(term, Math.log((this.totalDocs + 1) / ((this.docFrequency(term) + 1))));
-    }
-  }
-
-  addDocuments(docs: Array<{ id: string; content: string; meta?: Record<string, any> }>): void {
-    for (const d of docs) this.addDocument(d.id, d.content, d.meta);
-  }
-
-  private docFrequency(term: string): number {
-    let count = 0;
-    for (const d of this.docs) { if (d.tf.has(term)) count++; }
-    return count;
-  }
-
-  /** Search for documents similar to query. Returns [score, doc] pairs. */
-  search(query: string, topK: number = 5, minScore: number = 0.01): Array<[number, DocVector]> {
-    const queryTokens = tokenize(query);
-    const queryTf = new Map<string, number>();
-    for (const t of queryTokens) { queryTf.set(t, (queryTf.get(t) || 0) + 1); }
-
-    // Query vector
-    const qv = new Map<string, number>();
-    let qNormSq = 0;
-    for (const [term, freq] of queryTf) {
-      const tfVal = freq / queryTokens.length;
-      const idfVal = this.idf.get(term) || 0;
-      const val = tfVal * Math.max(0.1, idfVal);
-      qv.set(term, val);
-      qNormSq += val * val;
-    }
-    const qNorm = Math.sqrt(qNormSq);
-    if (qNorm === 0) return [];
-
-    // Cosine similarity against all docs
-    const scored: Array<[number, DocVector]> = [];
-    for (const doc of this.docs) {
-      if (doc.norm === 0) continue;
-      let dot = 0;
-      for (const [term, qVal] of qv) {
-        dot += qVal * (doc.tf.get(term) || 0);
-      }
-      const score = dot / (qNorm * doc.norm);
-      if (score >= minScore) scored.push([score, doc]);
-    }
-
-    scored.sort((a, b) => b[0] - a[0]);
-    return scored.slice(0, topK);
-  }
-
-  /** Remove a document by ID. */
-  removeDocument(id: string): void {
-    this.docs = this.docs.filter(d => d.id !== id);
-    this.totalDocs = this.docs.length;
-  }
-
-  get size(): number { return this.docs.length; }
-
-  clear(): void { this.docs = []; this.idf.clear(); this.totalDocs = 0; }
-}
-
-/* ═══════════════════════════════════════
-   Singleton instance for memory recall
-   ═══════════════════════════════════════ */
-let globalIndex: VectorIndex | null = null;
-
-export function getVectorIndex(): VectorIndex {
-  if (!globalIndex) globalIndex = new VectorIndex();
-  return globalIndex;
-}
-
-export function resetVectorIndex(): void {
-  globalIndex = new VectorIndex();
-}
+/**
+ * 向量语义搜索 — TF-IDF + Cosine similarity, zero dependencies.
+ *
+ * Replaces n-gram Jaccard as the default semantic scorer.
+ * - IDF pre-computed from document corpus
+ * - Cosine similarity on TF-IDF vectors
+ * - CJK-aware tokenization (bigram for CJK, whitespace for ASCII)
+ *
+ * Usage:
+ *   const idx = new VectorIndex();
+ *   idx.addDocuments(docs);
+ *   const results = idx.search("deploy script", 5);
+ */
+
+/* ═══════════════════════════════════════
+   Tokenizer — CJK-aware
+   ═══════════════════════════════════════ */
+const CJK = /[一-鿿぀-ゟ가-힯]/;
+
+function tokenize(text: string): string[] {
+  const tokens: string[] = [];
+  let i = 0;
+  while (i < text.length) {
+    if (CJK.test(text[i])) {
+      if (i + 1 < text.length && CJK.test(text[i + 1])) {
+        tokens.push(text.slice(i, i + 2)); i += 2;
+      } else {
+        tokens.push(text[i]); i++;
+      }
+    } else if (/[A-Za-z0-9_]/.test(text[i])) {
+      let j = i;
+      while (j < text.length && /[A-Za-z0-9_]/.test(text[j])) j++;
+      tokens.push(text.slice(i, j).toLowerCase()); i = j;
+    } else {
+      i++;
+    }
+  }
+  return tokens;
+}
+
+/* ═══════════════════════════════════════
+   TF-IDF Vector computation
+   ═══════════════════════════════════════ */
+interface DocVector {
+  id: string;
+  tf: Map<string, number>;
+  norm: number;
+  content: string;
+  meta?: Record<string, any>;
+}
+
+export class VectorIndex {
+  private docs: DocVector[] = [];
+  private idf: Map<string, number> = new Map();
+  private totalDocs = 0;
+
+  /** Add a document to the index. */
+  addDocument(id: string, content: string, meta?: Record<string, any>): void {
+    const tokens = tokenize(content);
+    const tf = new Map<string, number>();
+    for (const t of tokens) { tf.set(t, (tf.get(t) || 0) + 1); }
+
+    // Normalize by doc length
+    const tfIdf = new Map<string, number>();
+    let normSq = 0;
+    for (const [term, freq] of tf) {
+      const tfVal = freq / tokens.length;
+      const idfVal = this.idf.get(term) || 0;
+      const val = tfVal * Math.max(0.1, idfVal);
+      tfIdf.set(term, val);
+      normSq += val * val;
+    }
+
+    const norm = Math.sqrt(normSq);
+    this.docs.push({ id, tf: tfIdf, norm, content: content.slice(0, 500), meta });
+    this.totalDocs++;
+
+    // Update IDF
+    for (const term of tf.keys()) {
+      this.idf.set(term, Math.log((this.totalDocs + 1) / ((this.docFrequency(term) + 1))));
+    }
+  }
+
+  addDocuments(docs: Array<{ id: string; content: string; meta?: Record<string, any> }>): void {
+    for (const d of docs) this.addDocument(d.id, d.content, d.meta);
+  }
+
+  private docFrequency(term: string): number {
+    let count = 0;
+    for (const d of this.docs) { if (d.tf.has(term)) count++; }
+    return count;
+  }
+
+  /** Search for documents similar to query. Returns [score, doc] pairs. */
+  search(query: string, topK: number = 5, minScore: number = 0.01): Array<[number, DocVector]> {
+    const queryTokens = tokenize(query);
+    const queryTf = new Map<string, number>();
+    for (const t of queryTokens) { queryTf.set(t, (queryTf.get(t) || 0) + 1); }
+
+    // Query vector
+    const qv = new Map<string, number>();
+    let qNormSq = 0;
+    for (const [term, freq] of queryTf) {
+      const tfVal = freq / queryTokens.length;
+      const idfVal = this.idf.get(term) || 0;
+      const val = tfVal * Math.max(0.1, idfVal);
+      qv.set(term, val);
+      qNormSq += val * val;
+    }
+    const qNorm = Math.sqrt(qNormSq);
+    if (qNorm === 0) return [];
+
+    // Cosine similarity against all docs
+    const scored: Array<[number, DocVector]> = [];
+    for (const doc of this.docs) {
+      if (doc.norm === 0) continue;
+      let dot = 0;
+      for (const [term, qVal] of qv) {
+        dot += qVal * (doc.tf.get(term) || 0);
+      }
+      const score = dot / (qNorm * doc.norm);
+      if (score >= minScore) scored.push([score, doc]);
+    }
+
+    scored.sort((a, b) => b[0] - a[0]);
+    return scored.slice(0, topK);
+  }
+
+  /** Remove a document by ID. */
+  removeDocument(id: string): void {
+    this.docs = this.docs.filter(d => d.id !== id);
+    this.totalDocs = this.docs.length;
+  }
+
+  get size(): number { return this.docs.length; }
+
+  clear(): void { this.docs = []; this.idf.clear(); this.totalDocs = 0; }
+}
+
+/* ═══════════════════════════════════════
+   Singleton instance for memory recall
+   ═══════════════════════════════════════ */
+let globalIndex: VectorIndex | null = null;
+
+export function getVectorIndex(): VectorIndex {
+  if (!globalIndex) globalIndex = new VectorIndex();
+  return globalIndex;
+}
+
+export function resetVectorIndex(): void {
+  globalIndex = new VectorIndex();
+}

package/src/core/verify.ts

@@ -0,0 +1,71 @@
+/**
+ * 验证闭环 — give agents a way to check their own work.
+ *
+ * After a task that wrote files, the configured verify commands (tests,
+ * type-check, lint) run automatically; failures are fed back to the agent
+ * for a bounded number of fix rounds. Mirrors Claude Code's first best
+ * practice: output quality is transformed when the model can self-verify.
+ *
+ * Command sources (first non-empty wins):
+ *   1. config.yaml:  verify: { commands: [...], max_fix_rounds, timeout_s }
+ *   2. SKY.md "## Verify" section's fenced code block (see skymd.ts)
+ */
+
+import { spawnSync } from 'child_process';
+import { loadProjectMemory, parseVerifyCommands } from './skymd';
+
+export interface VerifyConfig {
+  commands: string[];
+  maxFixRounds: number;
+  timeoutS: number;
+}
+
+export interface VerifyResult {
+  ok: boolean;
+  /** Human/agent readable report (per-command status + failure tails). */
+  report: string;
+}
+
+const OUTPUT_TAIL = 4000;
+
+/** Resolve verify settings from config, falling back to SKY.md. */
+export function resolveVerifyConfig(config: any, cwd: string = process.cwd()): VerifyConfig {
+  const v: any = config?.verify || {};
+  let commands: string[] = Array.isArray(v.commands) ? v.commands.filter((c: any) => typeof c === 'string' && c.trim()) : [];
+  if (commands.length === 0) {
+    try {
+      commands = parseVerifyCommands(loadProjectMemory(cwd).text);
+    } catch {
+      commands = [];
+    }
+  }
+  return {
+    commands,
+    maxFixRounds: typeof v.max_fix_rounds === 'number' ? v.max_fix_rounds : 2,
+    timeoutS: typeof v.timeout_s === 'number' ? v.timeout_s : 300,
+  };
+}
+
+/** Run all verify commands sequentially; stop at the first failure. */
+export function runVerify(cfg: VerifyConfig, cwd: string = process.cwd()): VerifyResult {
+  const lines: string[] = [];
+  for (const cmd of cfg.commands) {
+    const r = spawnSync(cmd, {
+      shell: true,
+      cwd,
+      encoding: 'utf-8',
+      timeout: cfg.timeoutS * 1000,
+      env: { ...process.env, CI: '1', FORCE_COLOR: '0' },
+    });
+    const out = `${r.stdout || ''}${r.stderr || ''}`.trim();
+    if (r.status === 0) {
+      lines.push(`✓ ${cmd}`);
+    } else {
+      const tail = out.length > OUTPUT_TAIL ? '…' + out.slice(-OUTPUT_TAIL) : out;
+      const why = r.error ? String(r.error) : `exit ${r.status}`;
+      lines.push(`✗ ${cmd} (${why})\n${tail}`);
+      return { ok: false, report: lines.join('\n') };
+    }
+  }
+  return { ok: true, report: lines.join('\n') };
+}

package/src/core/workspace.ts

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