@cjhyy/code-shell 0.1.0-alpha.0

package/dist/chunk-3QR52LL5.cjs

@@ -0,0 +1,105 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); var _class;
+
+var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
+
+// src/session/file-history.ts
+_chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+var _fs = require('fs');
+var _path = require('path');
+var _crypto = require('crypto');
+var FileHistory = (_class = class _FileHistory {
+  
+  __init() {this.snapshots = []}
+  constructor(sessionDir) {;_class.prototype.__init.call(this);
+    this.historyDir = _path.join.call(void 0, sessionDir, "file-history");
+    _fs.mkdirSync.call(void 0, this.historyDir, { recursive: true });
+  }
+  /**
+   * Save a snapshot of a file before it is modified.
+   * Returns the snapshot record, or null if the file doesn't exist.
+   */
+  saveSnapshot(filePath) {
+    const absPath = _path.resolve.call(void 0, filePath);
+    if (!_fs.existsSync.call(void 0, absPath)) return null;
+    try {
+      const content = _fs.readFileSync.call(void 0, absPath);
+      const hash = _crypto.createHash.call(void 0, "md5").update(content).digest("hex");
+      const existing = this.snapshots.find(
+        (s) => s.filePath === absPath && s.hash === hash
+      );
+      if (existing) return existing;
+      const timestamp = Date.now();
+      const safeName = absPath.replace(/[/\\:]/g, "_").slice(-100);
+      const backupPath = _path.join.call(void 0, this.historyDir, `${timestamp}_${safeName}`);
+      _fs.copyFileSync.call(void 0, absPath, backupPath);
+      const snapshot = {
+        filePath: absPath,
+        timestamp,
+        backupPath,
+        hash,
+        size: content.length
+      };
+      this.snapshots.push(snapshot);
+      this.saveIndex();
+      return snapshot;
+    } catch (e) {
+      return null;
+    }
+  }
+  /**
+   * Get all snapshots for a specific file.
+   */
+  getSnapshots(filePath) {
+    const absPath = _path.resolve.call(void 0, filePath);
+    return this.snapshots.filter((s) => s.filePath === absPath).sort((a, b) => b.timestamp - a.timestamp);
+  }
+  /**
+   * Restore a file to a specific snapshot.
+   */
+  restore(snapshot) {
+    try {
+      if (!_fs.existsSync.call(void 0, snapshot.backupPath)) return false;
+      this.saveSnapshot(snapshot.filePath);
+      _fs.copyFileSync.call(void 0, snapshot.backupPath, snapshot.filePath);
+      return true;
+    } catch (e2) {
+      return false;
+    }
+  }
+  /**
+   * Restore a file to its most recent snapshot.
+   */
+  restoreLatest(filePath) {
+    const snapshots = this.getSnapshots(filePath);
+    if (snapshots.length === 0) return false;
+    return this.restore(snapshots[0]);
+  }
+  /**
+   * Get all tracked files.
+   */
+  getTrackedFiles() {
+    return [...new Set(this.snapshots.map((s) => s.filePath))];
+  }
+  saveIndex() {
+    try {
+      const indexPath = _path.join.call(void 0, this.historyDir, "index.json");
+      _fs.writeFileSync.call(void 0, indexPath, JSON.stringify(this.snapshots, null, 2), "utf-8");
+    } catch (e3) {
+    }
+  }
+  static loadFromDir(sessionDir) {
+    const history = new _FileHistory(sessionDir);
+    const indexPath = _path.join.call(void 0, history.historyDir, "index.json");
+    if (_fs.existsSync.call(void 0, indexPath)) {
+      try {
+        history.snapshots = JSON.parse(_fs.readFileSync.call(void 0, indexPath, "utf-8"));
+      } catch (e4) {
+      }
+    }
+    return history;
+  }
+}, _class);
+
+
+
+exports.FileHistory = FileHistory;

package/dist/chunk-4PKZPFCD.js

@@ -0,0 +1,136 @@
+import {
+  init_esm_shims
+} from "./chunk-DI7RDLOS.js";
+
+// src/session/memory.ts
+init_esm_shims();
+import { mkdirSync, existsSync, readFileSync, writeFileSync, readdirSync, unlinkSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var MemoryManager = class {
+  memoryDir;
+  indexPath;
+  constructor(projectDir) {
+    const baseDir = join(homedir(), ".code-shell");
+    if (projectDir) {
+      const projectHash = projectDir.replace(/[/\\:]/g, "-").replace(/^-/, "");
+      this.memoryDir = join(baseDir, "projects", projectHash, "memory");
+    } else {
+      this.memoryDir = join(baseDir, "memory");
+    }
+    this.indexPath = join(this.memoryDir, "MEMORY.md");
+    mkdirSync(this.memoryDir, { recursive: true });
+  }
+  getMemoryDir() {
+    return this.memoryDir;
+  }
+  /**
+   * Save a memory entry. Creates the file and updates the index.
+   */
+  save(entry) {
+    const fileName = this.slugify(entry.name) + ".md";
+    const filePath = join(this.memoryDir, fileName);
+    const content = `---
+name: ${entry.name}
+description: ${entry.description}
+type: ${entry.type}
+---
+
+${entry.content}
+`;
+    writeFileSync(filePath, content, "utf-8");
+    this.updateIndex();
+    return fileName;
+  }
+  /**
+   * Load all memory entries.
+   */
+  loadAll() {
+    if (!existsSync(this.memoryDir)) return [];
+    const files = readdirSync(this.memoryDir).filter(
+      (f) => f.endsWith(".md") && f !== "MEMORY.md"
+    );
+    const entries = [];
+    for (const file of files) {
+      const entry = this.loadFile(file);
+      if (entry) entries.push(entry);
+    }
+    return entries;
+  }
+  /**
+   * Load a single memory file.
+   */
+  loadFile(fileName) {
+    const filePath = join(this.memoryDir, fileName);
+    if (!existsSync(filePath)) return null;
+    try {
+      const raw = readFileSync(filePath, "utf-8");
+      const frontmatterMatch = raw.match(/^---\n([\s\S]*?)\n---\n\n?([\s\S]*)$/);
+      if (!frontmatterMatch) return null;
+      const frontmatter = frontmatterMatch[1];
+      const content = frontmatterMatch[2].trim();
+      const name = frontmatter.match(/name:\s*(.+)/)?.[1]?.trim() ?? fileName;
+      const description = frontmatter.match(/description:\s*(.+)/)?.[1]?.trim() ?? "";
+      const type = frontmatter.match(/type:\s*(.+)/)?.[1]?.trim() ?? "project";
+      return { name, description, type, content, fileName };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Delete a memory by name or filename.
+   */
+  delete(nameOrFile) {
+    const entries = this.loadAll();
+    const entry = entries.find(
+      (e) => e.name === nameOrFile || e.fileName === nameOrFile
+    );
+    if (!entry) return false;
+    try {
+      unlinkSync(join(this.memoryDir, entry.fileName));
+      this.updateIndex();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get the MEMORY.md index content for injection into prompts.
+   */
+  getIndex() {
+    if (!existsSync(this.indexPath)) return "";
+    return readFileSync(this.indexPath, "utf-8");
+  }
+  /**
+   * Build a prompt-friendly summary of all memories.
+   */
+  buildMemoryContext() {
+    const entries = this.loadAll();
+    if (entries.length === 0) return "";
+    const lines = entries.map(
+      (e) => `- [${e.type}] ${e.name}: ${e.description}`
+    );
+    return `# Persistent Memory
+
+The following memories from previous sessions may be relevant:
+
+` + lines.join("\n") + `
+
+To read a specific memory, check ~/.code-shell/memory/`;
+  }
+  updateIndex() {
+    const entries = this.loadAll();
+    const lines = entries.map(
+      (e) => `- [${e.name}](${e.fileName}) \u2014 ${e.description}`
+    );
+    const content = lines.length > 0 ? lines.join("\n") + "\n" : "(no memories stored)\n";
+    writeFileSync(this.indexPath, content, "utf-8");
+  }
+  slugify(text) {
+    return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
+  }
+};
+
+export {
+  MemoryManager
+};

package/dist/chunk-4RRUP4MM.js

@@ -0,0 +1,86 @@
+import {
+  __esm,
+  init_esm_shims
+} from "./chunk-DI7RDLOS.js";
+
+// src/context/token-counter.ts
+function estimateStringTokens(text) {
+  if (!text) return 0;
+  const cjkChars = (text.match(/[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/g) ?? []).length;
+  const cjkRatio = cjkChars / text.length;
+  if (cjkRatio > 0.3) {
+    const cjkTokens = cjkChars / RATIOS.cjk;
+    const otherChars = text.length - cjkChars;
+    const otherTokens = otherChars / RATIOS.english;
+    return Math.ceil(cjkTokens + otherTokens);
+  }
+  const codeIndicators = ["{", "}", "(", ")", ";", "=>", "import ", "function ", "class ", "const "];
+  const codeScore = codeIndicators.reduce((s, ind) => s + (text.includes(ind) ? 1 : 0), 0);
+  if (codeScore >= 3) return Math.ceil(text.length / RATIOS.code);
+  if (text.startsWith("{") || text.startsWith("[")) return Math.ceil(text.length / RATIOS.json);
+  return Math.ceil(text.length / RATIOS.english);
+}
+function estimateMessagesTokens(messages) {
+  let total = 0;
+  for (const msg of messages) {
+    total += 4;
+    if (typeof msg.content === "string") {
+      total += estimateStringTokens(msg.content);
+    } else if (Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        total += estimateBlockTokens(block);
+      }
+    }
+  }
+  return total;
+}
+function estimateBlockTokens(block) {
+  let tokens = 2;
+  if (block.text) tokens += estimateStringTokens(block.text);
+  if (block.content && typeof block.content === "string") {
+    tokens += estimateStringTokens(block.content);
+  }
+  if (block.input) {
+    tokens += estimateStringTokens(JSON.stringify(block.input));
+  }
+  if (block.name) tokens += estimateStringTokens(block.name);
+  return tokens;
+}
+function calculateContextUsage(messages, systemPrompt, maxTokens) {
+  const systemPromptTokens = estimateStringTokens(systemPrompt);
+  const messagesTokens = estimateMessagesTokens(messages);
+  const usedTokens = systemPromptTokens + messagesTokens;
+  return {
+    usedTokens,
+    maxTokens,
+    usagePercent: usedTokens / maxTokens * 100,
+    systemPromptTokens,
+    messagesTokens,
+    headroom: maxTokens - usedTokens
+  };
+}
+var RATIOS;
+var init_token_counter = __esm({
+  "src/context/token-counter.ts"() {
+    init_esm_shims();
+    RATIOS = {
+      english: 4,
+      // ~4 chars per token for English prose
+      code: 3.2,
+      // ~3.2 chars per token for code (more tokens per char)
+      json: 3.5,
+      // JSON structures
+      mixed: 3.6,
+      // Mixed content (typical for tool results)
+      cjk: 1.5
+      // CJK characters: ~1.5 chars per token
+    };
+  }
+});
+
+export {
+  estimateStringTokens,
+  estimateMessagesTokens,
+  calculateContextUsage,
+  init_token_counter
+};

package/dist/chunk-4SFPFHMG.js

@@ -0,0 +1,132 @@
+import {
+  init_esm_shims
+} from "./chunk-DI7RDLOS.js";
+
+// src/skills/index.ts
+init_esm_shims();
+
+// src/skills/scanner.ts
+init_esm_shims();
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { join, resolve } from "path";
+import { homedir } from "os";
+function scanSkills(cwd) {
+  const skills = [];
+  const seen = /* @__PURE__ */ new Set();
+  const dirs = [
+    // Project-level
+    join(cwd, ".code-shell", "skills"),
+    join(cwd, ".claude", "skills"),
+    // User-level
+    join(homedir(), ".code-shell", "skills"),
+    join(homedir(), ".claude", "skills")
+  ];
+  for (const dir of dirs) {
+    if (!existsSync(dir)) continue;
+    try {
+      const files = readdirSync(dir).filter(
+        (f) => f.endsWith(".md") && statSync(join(dir, f)).isFile()
+      );
+      for (const file of files) {
+        const filePath = resolve(join(dir, file));
+        if (seen.has(filePath)) continue;
+        seen.add(filePath);
+        const skill = parseSkillFile(filePath);
+        if (skill) skills.push(skill);
+      }
+    } catch {
+    }
+  }
+  return skills;
+}
+function parseSkillFile(filePath) {
+  try {
+    const raw = readFileSync(filePath, "utf-8");
+    const match = raw.match(/^---\n([\s\S]*?)\n---\n\n?([\s\S]*)$/);
+    if (!match) return null;
+    const frontmatter = match[1];
+    const content = match[2].trim();
+    const name = extractField(frontmatter, "name");
+    if (!name) return null;
+    const description = extractField(frontmatter, "description") ?? "";
+    const whenToUse = extractField(frontmatter, "when_to_use") ?? "";
+    const keywords = extractList(frontmatter, "keywords");
+    const tools = extractList(frontmatter, "tools");
+    const intents = extractList(frontmatter, "intents");
+    return {
+      name,
+      description,
+      triggers: { keywords, tools, intents },
+      whenToUse,
+      content,
+      filePath
+    };
+  } catch {
+    return null;
+  }
+}
+function extractField(frontmatter, field) {
+  const match = frontmatter.match(new RegExp(`^${field}:\\s*(.+)$`, "m"));
+  return match?.[1]?.trim();
+}
+function extractList(frontmatter, field) {
+  const match = frontmatter.match(new RegExp(`${field}:\\s*\\[([^\\]]+)\\]`));
+  if (!match) return [];
+  return match[1].split(",").map((s) => s.trim().replace(/^['"]|['"]$/g, ""));
+}
+
+// src/skills/matcher.ts
+init_esm_shims();
+function matchSkillsByInput(skills, input) {
+  const inputLower = input.toLowerCase();
+  const results = [];
+  for (const skill of skills) {
+    let bestScore = 0;
+    let matchedBy = "";
+    if (skill.triggers.keywords) {
+      for (const kw of skill.triggers.keywords) {
+        if (inputLower.includes(kw.toLowerCase())) {
+          const score = kw.length / input.length * 10 + 5;
+          if (score > bestScore) {
+            bestScore = score;
+            matchedBy = "keyword";
+          }
+        }
+      }
+    }
+    if (skill.triggers.intents) {
+      for (const intent of skill.triggers.intents) {
+        if (inputLower.includes(intent.toLowerCase())) {
+          const score = 8;
+          if (score > bestScore) {
+            bestScore = score;
+            matchedBy = "intent";
+          }
+        }
+      }
+    }
+    if (bestScore > 0) {
+      results.push({ skill, score: bestScore, matchedBy });
+    }
+  }
+  return results.sort((a, b) => b.score - a.score);
+}
+function matchSkillsByTool(skills, toolName) {
+  return skills.filter((s) => s.triggers.tools?.includes(toolName)).map((skill) => ({ skill, score: 10, matchedBy: "tool" }));
+}
+function buildSkillListing(skills) {
+  if (skills.length === 0) return "";
+  const lines = skills.map(
+    (s) => `- **${s.name}**: ${s.description}${s.whenToUse ? ` \u2014 Use when: ${s.whenToUse}` : ""}`
+  );
+  return `# Available Skills
+
+${lines.join("\n")}`;
+}
+
+export {
+  scanSkills,
+  matchSkillsByInput,
+  matchSkillsByTool,
+  buildSkillListing
+};