@contractspec/module.ai-chat 1.57.0 → 1.59.0

package/dist/browser/context/index.js

@@ -0,0 +1,415 @@
+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');
+});
+
+// src/context/workspace-context.ts
+class WorkspaceContext {
+  workspacePath;
+  allowWrites;
+  specs = [];
+  files = [];
+  initialized = false;
+  constructor(config) {
+    this.workspacePath = config.workspacePath;
+    this.allowWrites = config.allowWrites ?? false;
+  }
+  async initialize() {
+    if (this.initialized)
+      return;
+    this.initialized = true;
+  }
+  getSpecs() {
+    return this.specs;
+  }
+  getFiles() {
+    return this.files;
+  }
+  addSpecs(specs) {
+    this.specs.push(...specs);
+  }
+  addFiles(files) {
+    this.files.push(...files);
+  }
+  getSummary() {
+    const commands = this.specs.filter((s) => s.type === "command").length;
+    const queries = this.specs.filter((s) => s.type === "query").length;
+    const events = this.specs.filter((s) => s.type === "event").length;
+    const presentations = this.specs.filter((s) => s.type === "presentation").length;
+    const tsFiles = this.files.filter((f) => f.extension === ".ts").length;
+    const specFiles = this.files.filter((f) => f.isSpec).length;
+    return {
+      name: this.workspacePath.split("/").pop() ?? "workspace",
+      path: this.workspacePath,
+      specs: {
+        total: this.specs.length,
+        commands,
+        queries,
+        events,
+        presentations
+      },
+      files: {
+        total: this.files.length,
+        typescript: tsFiles,
+        specFiles
+      }
+    };
+  }
+  getContextSummary() {
+    const summary = this.getSummary();
+    const parts = [
+      `Workspace: ${summary.name}`,
+      `Path: ${summary.path}`,
+      "",
+      "### Specs",
+      `- Commands: ${summary.specs.commands}`,
+      `- Queries: ${summary.specs.queries}`,
+      `- Events: ${summary.specs.events}`,
+      `- Presentations: ${summary.specs.presentations}`
+    ];
+    if (this.specs.length > 0) {
+      parts.push("", "### Available Specs");
+      for (const spec of this.specs.slice(0, 20)) {
+        parts.push(`- ${spec.name} (${spec.type})`);
+      }
+      if (this.specs.length > 20) {
+        parts.push(`- ... and ${this.specs.length - 20} more`);
+      }
+    }
+    return parts.join(`
+`);
+  }
+  findSpecs(query) {
+    const lowerQuery = query.toLowerCase();
+    return this.specs.filter((s) => s.name.toLowerCase().includes(lowerQuery) || s.description?.toLowerCase().includes(lowerQuery) || s.tags?.some((t) => t.toLowerCase().includes(lowerQuery)));
+  }
+  findFiles(query) {
+    const lowerQuery = query.toLowerCase();
+    return this.files.filter((f) => f.path.toLowerCase().includes(lowerQuery) || f.name.toLowerCase().includes(lowerQuery));
+  }
+}
+async function createWorkspaceContext(path, options) {
+  const context = new WorkspaceContext({
+    workspacePath: path,
+    ...options
+  });
+  await context.initialize();
+  return context;
+}
+// src/context/context-builder.ts
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function scoreSpec(spec, query) {
+  if (!query)
+    return 0.5;
+  const lowerQuery = query.toLowerCase();
+  let score = 0;
+  if (spec.name.toLowerCase().includes(lowerQuery)) {
+    score += 0.4;
+  }
+  if (spec.description?.toLowerCase().includes(lowerQuery)) {
+    score += 0.3;
+  }
+  if (spec.tags?.some((t) => t.toLowerCase().includes(lowerQuery))) {
+    score += 0.2;
+  }
+  return Math.min(score, 1);
+}
+function scoreFile(file, query) {
+  if (!query)
+    return 0.5;
+  const lowerQuery = query.toLowerCase();
+  let score = 0;
+  if (file.path.toLowerCase().includes(lowerQuery)) {
+    score += 0.5;
+  }
+  if (file.name.toLowerCase().includes(lowerQuery)) {
+    score += 0.3;
+  }
+  if (file.isSpec) {
+    score += 0.2;
+  }
+  return Math.min(score, 1);
+}
+
+class ContextBuilder {
+  context;
+  constructor(context) {
+    this.context = context;
+  }
+  build(options = {}) {
+    const maxTokens = options.maxTokens ?? 4000;
+    const entries = [];
+    let totalTokens = 0;
+    if (options.includeSpecs?.length) {
+      for (const specName of options.includeSpecs) {
+        const spec = this.context.getSpecs().find((s) => s.name === specName);
+        if (spec) {
+          const entry = {
+            type: "spec",
+            path: spec.path,
+            summary: `${spec.type}: ${spec.name}${spec.description ? ` - ${spec.description}` : ""}`,
+            relevance: 1
+          };
+          entries.push(entry);
+          totalTokens += estimateTokens(entry.summary ?? "");
+        }
+      }
+    }
+    if (options.includeFiles?.length) {
+      for (const filePath of options.includeFiles) {
+        const file = this.context.getFiles().find((f) => f.path === filePath);
+        if (file) {
+          const entry = {
+            type: "file",
+            path: file.path,
+            summary: `File: ${file.relativePath}`,
+            relevance: 1
+          };
+          entries.push(entry);
+          totalTokens += estimateTokens(entry.summary ?? "");
+        }
+      }
+    }
+    if (options.query) {
+      const scoredSpecs = this.context.getSpecs().map((spec) => ({ spec, score: scoreSpec(spec, options.query) })).filter(({ score }) => score > 0.2).sort((a, b) => b.score - a.score);
+      for (const { spec, score } of scoredSpecs) {
+        if (totalTokens >= maxTokens)
+          break;
+        if (entries.some((e) => e.path === spec.path))
+          continue;
+        const entry = {
+          type: "spec",
+          path: spec.path,
+          summary: `${spec.type}: ${spec.name}${spec.description ? ` - ${spec.description}` : ""}`,
+          relevance: score
+        };
+        entries.push(entry);
+        totalTokens += estimateTokens(entry.summary ?? "");
+      }
+    }
+    if (options.query) {
+      const scoredFiles = this.context.getFiles().map((file) => ({ file, score: scoreFile(file, options.query) })).filter(({ score }) => score > 0.2).sort((a, b) => b.score - a.score);
+      for (const { file, score } of scoredFiles) {
+        if (totalTokens >= maxTokens)
+          break;
+        if (entries.some((e) => e.path === file.path))
+          continue;
+        const entry = {
+          type: "file",
+          path: file.path,
+          summary: `File: ${file.relativePath}`,
+          relevance: score
+        };
+        entries.push(entry);
+        totalTokens += estimateTokens(entry.summary ?? "");
+      }
+    }
+    const summary = this.buildSummary(entries);
+    return {
+      entries,
+      summary,
+      totalTokensEstimate: totalTokens + estimateTokens(summary)
+    };
+  }
+  buildSummary(entries) {
+    if (entries.length === 0) {
+      return this.context.getContextSummary();
+    }
+    const parts = [];
+    const workspaceSummary = this.context.getSummary();
+    parts.push(`Workspace: ${workspaceSummary.name}`);
+    parts.push("");
+    const specs = entries.filter((e) => e.type === "spec");
+    if (specs.length > 0) {
+      parts.push("### Relevant Specs");
+      for (const entry of specs) {
+        parts.push(`- ${entry.summary}`);
+      }
+      parts.push("");
+    }
+    const files = entries.filter((e) => e.type === "file");
+    if (files.length > 0) {
+      parts.push("### Relevant Files");
+      for (const entry of files) {
+        parts.push(`- ${entry.summary}`);
+      }
+    }
+    return parts.join(`
+`);
+  }
+}
+function createContextBuilder(context) {
+  return new ContextBuilder(context);
+}
+// src/context/file-operations.ts
+class FileOperations {
+  fs;
+  workspacePath;
+  allowWrites;
+  constructor(fs, workspacePath, allowWrites = false) {
+    this.fs = fs;
+    this.workspacePath = workspacePath;
+    this.allowWrites = allowWrites;
+  }
+  async read(relativePath) {
+    const fullPath = this.resolvePath(relativePath);
+    try {
+      const content = await this.fs.readFile(fullPath);
+      return { success: true, path: relativePath, content };
+    } catch (error) {
+      return {
+        success: false,
+        path: relativePath,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async write(relativePath, content) {
+    if (!this.allowWrites) {
+      return {
+        success: false,
+        path: relativePath,
+        error: "File writes are not enabled"
+      };
+    }
+    const fullPath = this.resolvePath(relativePath);
+    try {
+      await this.fs.writeFile(fullPath, content);
+      return { success: true, path: relativePath };
+    } catch (error) {
+      return {
+        success: false,
+        path: relativePath,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async execute(operations) {
+    const results = [];
+    for (const operation of operations) {
+      let result;
+      switch (operation.type) {
+        case "read": {
+          const readResult = await this.read(operation.path);
+          result = {
+            operation,
+            success: readResult.success,
+            content: readResult.content,
+            error: readResult.error
+          };
+          break;
+        }
+        case "write":
+        case "create": {
+          if (!operation.content) {
+            result = {
+              operation,
+              success: false,
+              error: "Content is required for write operations"
+            };
+          } else {
+            const writeResult = await this.write(operation.path, operation.content);
+            result = {
+              operation,
+              success: writeResult.success,
+              error: writeResult.error
+            };
+          }
+          break;
+        }
+        case "delete": {
+          if (!this.allowWrites) {
+            result = {
+              operation,
+              success: false,
+              error: "File writes are not enabled"
+            };
+          } else {
+            try {
+              await this.fs.deleteFile(this.resolvePath(operation.path));
+              result = { operation, success: true };
+            } catch (error) {
+              result = {
+                operation,
+                success: false,
+                error: error instanceof Error ? error.message : String(error)
+              };
+            }
+          }
+          break;
+        }
+        default:
+          result = {
+            operation,
+            success: false,
+            error: `Unknown operation type: ${operation.type}`
+          };
+      }
+      results.push(result);
+    }
+    return results;
+  }
+  resolvePath(relativePath) {
+    const normalized = relativePath.replace(/\.\./g, "").replace(/^\//, "");
+    return `${this.workspacePath}/${normalized}`;
+  }
+}
+function createNodeFileOperations(workspacePath, allowWrites = false) {
+  const fs = {
+    async readFile(path) {
+      const { readFile } = await import("node:fs/promises");
+      return readFile(path, "utf-8");
+    },
+    async writeFile(path, content) {
+      const { writeFile, mkdir } = await import("node:fs/promises");
+      const { dirname } = await import("node:path");
+      await mkdir(dirname(path), { recursive: true });
+      await writeFile(path, content, "utf-8");
+    },
+    async exists(path) {
+      const { access } = await import("node:fs/promises");
+      try {
+        await access(path);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async deleteFile(path) {
+      const { unlink } = await import("node:fs/promises");
+      await unlink(path);
+    },
+    async listFiles(directory, options) {
+      const { readdir } = await import("node:fs/promises");
+      const { join } = await import("node:path");
+      const files = [];
+      const entries = await readdir(directory, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join(directory, entry.name);
+        if (entry.isDirectory() && options?.recursive) {
+          const subFiles = await this.listFiles(fullPath, options);
+          files.push(...subFiles);
+        } else if (entry.isFile()) {
+          if (!options?.pattern || entry.name.match(new RegExp(options.pattern))) {
+            files.push(fullPath);
+          }
+        }
+      }
+      return files;
+    }
+  };
+  return new FileOperations(fs, workspacePath, allowWrites);
+}
+export {
+  createWorkspaceContext,
+  createNodeFileOperations,
+  createContextBuilder,
+  WorkspaceContext,
+  FileOperations,
+  ContextBuilder
+};