codmir 0.4.0 → 0.6.0

package/dist/{chunk-EBO3CZXG.mjs → chunk-3RG5ZIWI.js}

@@ -1,15 +1,10 @@
-var __getOwnPropNames = Object.getOwnPropertyNames;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
 
 export {
-  __require,
-  __commonJS
+  __require
 };

package/dist/chunk-5XZIEJ3P.js

@@ -0,0 +1,231 @@
+// src/sync/cloud-sync.ts
+import WebSocket from "ws";
+var WebSocketCloudSync = class {
+  config;
+  ws = null;
+  messageHandlers = /* @__PURE__ */ new Set();
+  pendingMessages = [];
+  reconnectAttempts = 0;
+  maxReconnectAttempts = 5;
+  heartbeatInterval = null;
+  constructor(config) {
+    this.config = config;
+  }
+  async connect() {
+    if (!this.config.enabled || !this.config.apiUrl) {
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      const wsUrl = this.config.apiUrl.replace("https://", "wss://").replace("http://", "ws://");
+      const url = `${wsUrl}/api/agent/ws?apiKey=${this.config.apiKey || ""}`;
+      this.ws = new WebSocket(url);
+      this.ws.on("open", () => {
+        console.log("[CloudSync] Connected to Codmir cloud");
+        this.reconnectAttempts = 0;
+        for (const msg of this.pendingMessages) {
+          this.emitEvent(msg);
+        }
+        this.pendingMessages = [];
+        this.startHeartbeat();
+        resolve();
+      });
+      this.ws.on("message", (data) => {
+        try {
+          const message = JSON.parse(data.toString());
+          for (const handler of this.messageHandlers) {
+            handler(message);
+          }
+        } catch (error) {
+          console.error("[CloudSync] Failed to parse message:", error);
+        }
+      });
+      this.ws.on("close", () => {
+        console.log("[CloudSync] Disconnected from cloud");
+        this.stopHeartbeat();
+        this.attemptReconnect();
+      });
+      this.ws.on("error", (error) => {
+        console.error("[CloudSync] WebSocket error:", error.message);
+        reject(error);
+      });
+      setTimeout(() => {
+        if (this.ws?.readyState !== WebSocket.OPEN) {
+          reject(new Error("Connection timeout"));
+        }
+      }, 1e4);
+    });
+  }
+  startHeartbeat() {
+    this.heartbeatInterval = setInterval(() => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.ping();
+      }
+    }, 3e4);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+  attemptReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.log("[CloudSync] Max reconnect attempts reached");
+      return;
+    }
+    this.reconnectAttempts++;
+    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 3e4);
+    console.log(`[CloudSync] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+    setTimeout(() => {
+      this.connect().catch(() => {
+      });
+    }, delay);
+  }
+  disconnect() {
+    this.stopHeartbeat();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  async createTask(session) {
+    const task = {
+      id: session.taskId || session.id,
+      userId: this.config.userId || "anonymous",
+      projectId: this.config.projectId,
+      title: session.prompt.slice(0, 100),
+      description: session.prompt,
+      status: session.status,
+      source: "cli",
+      workspaceRoot: session.workspaceRoot,
+      steps: session.steps,
+      files: session.files,
+      createdAt: new Date(session.createdAt).toISOString(),
+      updatedAt: new Date(session.updatedAt).toISOString()
+    };
+    if (this.ws?.readyState !== WebSocket.OPEN) {
+      return this.createTaskREST(task);
+    }
+    this.ws.send(JSON.stringify({
+      type: "task.create",
+      task
+    }));
+    return task;
+  }
+  async createTaskREST(task) {
+    if (!this.config.apiUrl) {
+      return task;
+    }
+    try {
+      const response = await fetch(`${this.config.apiUrl}/api/tasks`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.config.apiKey}`
+        },
+        body: JSON.stringify(task)
+      });
+      if (response.ok) {
+        return await response.json();
+      }
+    } catch (error) {
+      console.error("[CloudSync] Failed to create task via REST:", error);
+    }
+    return task;
+  }
+  async updateTask(taskId, updates) {
+    const payload = {
+      type: "task.update",
+      taskId,
+      updates: {
+        status: updates.status,
+        steps: updates.steps,
+        files: updates.files,
+        error: updates.error,
+        result: updates.result,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        completedAt: updates.completedAt ? new Date(updates.completedAt).toISOString() : void 0
+      }
+    };
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(payload));
+    } else {
+      this.updateTaskREST(taskId, payload.updates).catch(() => {
+      });
+    }
+  }
+  async updateTaskREST(taskId, updates) {
+    if (!this.config.apiUrl) return;
+    try {
+      await fetch(`${this.config.apiUrl}/api/tasks/${taskId}`, {
+        method: "PATCH",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.config.apiKey}`
+        },
+        body: JSON.stringify(updates)
+      });
+    } catch (error) {
+      console.error("[CloudSync] Failed to update task via REST:", error);
+    }
+  }
+  emitEvent(event) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify({
+        type: "event",
+        event
+      }));
+    } else {
+      this.pendingMessages.push(event);
+    }
+  }
+  onMessage(handler) {
+    this.messageHandlers.add(handler);
+    return () => this.messageHandlers.delete(handler);
+  }
+  isConnected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+};
+var NoopCloudSync = class {
+  async connect() {
+  }
+  disconnect() {
+  }
+  async createTask(session) {
+    return {
+      id: session.id,
+      userId: "local",
+      title: session.prompt.slice(0, 100),
+      description: session.prompt,
+      status: session.status,
+      source: "cli",
+      workspaceRoot: session.workspaceRoot,
+      steps: session.steps,
+      files: session.files,
+      createdAt: new Date(session.createdAt).toISOString(),
+      updatedAt: new Date(session.updatedAt).toISOString()
+    };
+  }
+  async updateTask() {
+  }
+  emitEvent() {
+  }
+  onMessage() {
+    return () => {
+    };
+  }
+  isConnected() {
+    return false;
+  }
+};
+function createCloudSync(config) {
+  if (!config?.enabled) {
+    return new NoopCloudSync();
+  }
+  return new WebSocketCloudSync(config);
+}
+
+export {
+  createCloudSync
+};

package/dist/chunk-BQMZNWYV.js

@@ -0,0 +1,295 @@
+// src/context/local-context-provider.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import { spawn, exec } from "child_process";
+import { promisify } from "util";
+import { glob } from "glob";
+var execPromise = promisify(exec);
+var LocalContextProvider = class {
+  workspaceRoot;
+  askUserHandler;
+  notificationHandler;
+  constructor(workspaceRoot, options) {
+    this.workspaceRoot = path.resolve(workspaceRoot);
+    this.askUserHandler = options?.askUserHandler;
+    this.notificationHandler = options?.notificationHandler;
+  }
+  getWorkspaceRoot() {
+    return this.workspaceRoot;
+  }
+  resolvePath(relativePath) {
+    const resolved = path.resolve(this.workspaceRoot, relativePath);
+    if (!resolved.startsWith(this.workspaceRoot)) {
+      throw new Error(`Path escapes workspace: ${relativePath}`);
+    }
+    return resolved;
+  }
+  async readFile(filePath, options) {
+    const fullPath = this.resolvePath(filePath);
+    try {
+      const content = await fs.readFile(fullPath, "utf-8");
+      const lines = content.split("\n");
+      const lineCount = lines.length;
+      let resultContent = content;
+      let truncated = false;
+      if (options?.startLine || options?.endLine) {
+        const start = (options.startLine || 1) - 1;
+        const end = options.endLine || lines.length;
+        resultContent = lines.slice(start, end).join("\n");
+        truncated = start > 0 || end < lines.length;
+      }
+      if (options?.maxLength && resultContent.length > options.maxLength) {
+        resultContent = resultContent.slice(0, options.maxLength);
+        truncated = true;
+      }
+      const ext = path.extname(fullPath).slice(1);
+      const languageMap = {
+        ts: "typescript",
+        tsx: "typescript",
+        js: "javascript",
+        jsx: "javascript",
+        py: "python",
+        rb: "ruby",
+        go: "go",
+        rs: "rust",
+        java: "java",
+        c: "c",
+        cpp: "cpp",
+        h: "c",
+        hpp: "cpp",
+        cs: "csharp",
+        php: "php",
+        swift: "swift",
+        kt: "kotlin",
+        scala: "scala",
+        sh: "bash",
+        bash: "bash",
+        zsh: "bash",
+        fish: "fish",
+        ps1: "powershell",
+        sql: "sql",
+        json: "json",
+        yaml: "yaml",
+        yml: "yaml",
+        xml: "xml",
+        html: "html",
+        css: "css",
+        scss: "scss",
+        less: "less",
+        md: "markdown",
+        txt: "plaintext"
+      };
+      return {
+        content: resultContent,
+        path: filePath,
+        language: languageMap[ext] || "plaintext",
+        lineCount,
+        truncated
+      };
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new Error(`File not found: ${filePath}`);
+      }
+      throw error;
+    }
+  }
+  async writeFile(filePath, content) {
+    const fullPath = this.resolvePath(filePath);
+    const dir = path.dirname(fullPath);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(fullPath, content, "utf-8");
+  }
+  async deleteFile(filePath) {
+    const fullPath = this.resolvePath(filePath);
+    await fs.unlink(fullPath);
+  }
+  async listDirectory(dirPath) {
+    const fullPath = this.resolvePath(dirPath);
+    const entries = await fs.readdir(fullPath, { withFileTypes: true });
+    const result = [];
+    for (const entry of entries) {
+      const entryPath = path.join(dirPath, entry.name);
+      const stat2 = await fs.stat(path.join(fullPath, entry.name)).catch(() => null);
+      result.push({
+        name: entry.name,
+        path: entryPath,
+        type: entry.isDirectory() ? "directory" : "file",
+        size: stat2?.size
+      });
+    }
+    return result;
+  }
+  async fileExists(filePath) {
+    const fullPath = this.resolvePath(filePath);
+    try {
+      await fs.access(fullPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async searchFiles(query, options) {
+    const results = [];
+    const maxResults = options?.maxResults || 100;
+    const includePatterns = options?.include || ["**/*"];
+    const excludePatterns = options?.exclude || ["**/node_modules/**", "**/.git/**", "**/dist/**"];
+    for (const pattern of includePatterns) {
+      const files = await glob(pattern, {
+        cwd: this.workspaceRoot,
+        ignore: excludePatterns,
+        nodir: true,
+        absolute: false
+      });
+      for (const file of files) {
+        if (results.length >= maxResults) break;
+        try {
+          const content = await this.readFile(file);
+          const lines = content.content.split("\n");
+          const regex = new RegExp(query, options?.caseSensitive ? "g" : "gi");
+          for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const matches = line.matchAll(regex);
+            for (const match of matches) {
+              if (results.length >= maxResults) break;
+              results.push({
+                path: file,
+                line: i + 1,
+                column: (match.index || 0) + 1,
+                match: match[0],
+                context: line.trim()
+              });
+            }
+          }
+        } catch {
+        }
+      }
+    }
+    return results;
+  }
+  async runCommand(command, options) {
+    const cwd = options?.cwd ? this.resolvePath(options.cwd) : this.workspaceRoot;
+    const timeout = options?.timeout || 3e4;
+    const startTime = Date.now();
+    return new Promise((resolve2, reject) => {
+      const proc = spawn("bash", ["-c", command], {
+        cwd,
+        env: { ...process.env, ...options?.env },
+        timeout
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("close", (code) => {
+        resolve2({
+          exitCode: code ?? 0,
+          stdout,
+          stderr,
+          duration: Date.now() - startTime
+        });
+      });
+      proc.on("error", (error) => {
+        reject(error);
+      });
+      setTimeout(() => {
+        proc.kill("SIGTERM");
+        reject(new Error(`Command timed out after ${timeout}ms`));
+      }, timeout);
+    });
+  }
+  async getGitStatus() {
+    try {
+      const branchResult = await execPromise("git rev-parse --abbrev-ref HEAD", {
+        cwd: this.workspaceRoot
+      });
+      const branch = branchResult.stdout.trim();
+      const statusResult = await execPromise("git status --porcelain", {
+        cwd: this.workspaceRoot
+      });
+      const staged = [];
+      const modified = [];
+      const untracked = [];
+      const deleted = [];
+      for (const line of statusResult.stdout.split("\n")) {
+        if (!line) continue;
+        const status = line.substring(0, 2);
+        const file = line.substring(3);
+        if (status.includes("?")) {
+          untracked.push(file);
+        } else if (status.includes("D")) {
+          deleted.push(file);
+        } else if (status[0] !== " ") {
+          staged.push(file);
+        } else if (status[1] !== " ") {
+          modified.push(file);
+        }
+      }
+      let ahead = 0;
+      let behind = 0;
+      try {
+        const trackingResult = await execPromise(
+          "git rev-list --left-right --count HEAD...@{upstream}",
+          { cwd: this.workspaceRoot }
+        );
+        const [a, b] = trackingResult.stdout.trim().split("	").map(Number);
+        ahead = a || 0;
+        behind = b || 0;
+      } catch {
+      }
+      return { branch, ahead, behind, staged, modified, untracked, deleted };
+    } catch (error) {
+      return {
+        branch: "unknown",
+        ahead: 0,
+        behind: 0,
+        staged: [],
+        modified: [],
+        untracked: [],
+        deleted: []
+      };
+    }
+  }
+  async getGitDiff(options) {
+    let cmd = "git diff";
+    if (options?.staged) {
+      cmd += " --staged";
+    }
+    if (options?.commit) {
+      cmd += ` ${options.commit}`;
+    }
+    if (options?.path) {
+      cmd += ` -- ${options.path}`;
+    }
+    try {
+      const result = await execPromise(cmd, { cwd: this.workspaceRoot });
+      return result.stdout;
+    } catch {
+      return "";
+    }
+  }
+  async askUser(question, options) {
+    if (this.askUserHandler) {
+      return this.askUserHandler(question, options);
+    }
+    throw new Error("No askUser handler configured");
+  }
+  showNotification(message, type) {
+    if (this.notificationHandler) {
+      this.notificationHandler(message, type);
+    } else {
+      console.log(`[${type || "info"}] ${message}`);
+    }
+  }
+};
+function createLocalContextProvider(workspaceRoot, options) {
+  return new LocalContextProvider(workspaceRoot, options);
+}
+
+export {
+  LocalContextProvider,
+  createLocalContextProvider
+};

package/dist/context/index.js

@@ -0,0 +1,9 @@
+import {
+  LocalContextProvider,
+  createLocalContextProvider
+} from "../chunk-BQMZNWYV.js";
+import "../chunk-3RG5ZIWI.js";
+export {
+  LocalContextProvider,
+  createLocalContextProvider
+};