@cdoing/core 0.1.0

package/src/utils/lazy-apply.ts

@@ -0,0 +1,189 @@
+/**
+ * Lazy Apply — LLM-assisted placeholder expansion for file edits.
+ *
+ * When an LLM generates code with placeholder markers like:
+ *   // ... existing code ...
+ *   // ... rest of the function ...
+ *   # ... remaining imports ...
+ *
+ * This module detects those placeholders and expands them by preserving
+ * the corresponding original code sections. This allows LLMs to make
+ * targeted edits without reproducing entire files.
+ *
+ * Three strategies:
+ *   1. Deterministic — match anchors (lines before/after placeholder) against
+ *      original content and splice in the preserved region
+ *   2. Unified diff — if the new content is a diff, apply it directly
+ *   3. Streaming — process token-by-token as LLM generates, expanding in real-time
+ */
+
+/**
+ * Common placeholder patterns used by LLMs to indicate "keep existing code here".
+ * Matches patterns like:
+ *   // ... existing code ...
+ *   // ... rest of the function ...
+ *   # ... remaining imports ...
+ *   /* ... keep existing ... * /
+ *   // [existing code]
+ *   // (rest remains the same)
+ */
+const PLACEHOLDER_PATTERNS = [
+  // Comment-style with ellipsis: // ... existing code ...
+  /^(\s*)(?:\/\/|#|--|\/\*|\*|<!--)\s*\.{2,}\s*(existing|remaining|rest|keep|same|unchanged|other|previous).*$/i,
+  // Comment-style with brackets: // [existing code]
+  /^(\s*)(?:\/\/|#|--|\/\*|\*|<!--)\s*\[(?:existing|remaining|rest|keep|same|unchanged|other|previous).*\].*$/i,
+  // Comment-style with parens: // (rest remains the same)
+  /^(\s*)(?:\/\/|#|--|\/\*|\*|<!--)\s*\((?:existing|remaining|rest|keep|same|unchanged|other|previous).*\).*$/i,
+  // Bare ellipsis comment: // ...
+  /^(\s*)(?:\/\/|#|--|\/\*|\*|<!--)\s*\.{3,}\s*(?:\*\/|-->)?\s*$/,
+];
+
+export interface LazyApplyResult {
+  content: string;
+  placeholdersExpanded: number;
+  strategy: "deterministic" | "none";
+}
+
+/**
+ * Check if a line is a placeholder marker.
+ */
+export function isPlaceholderLine(line: string): boolean {
+  return PLACEHOLDER_PATTERNS.some((p) => p.test(line));
+}
+
+/**
+ * Detect if content contains any placeholder markers.
+ */
+export function hasPlaceholders(content: string): boolean {
+  return content.split("\n").some(isPlaceholderLine);
+}
+
+/**
+ * Expand placeholders in newContent by referencing originalContent.
+ *
+ * Algorithm:
+ * 1. Split both contents into lines
+ * 2. Walk through newContent lines
+ * 3. When a placeholder line is found:
+ *    a. Use anchor lines (the non-placeholder lines before and after) to locate
+ *       the corresponding region in the original file
+ *    b. Splice in the original lines between the anchors
+ * 4. Return the expanded content
+ */
+export function expandPlaceholders(
+  originalContent: string,
+  newContent: string,
+): LazyApplyResult {
+  const newLines = newContent.split("\n");
+
+  if (!newLines.some(isPlaceholderLine)) {
+    return { content: newContent, placeholdersExpanded: 0, strategy: "none" };
+  }
+
+  const originalLines = originalContent.split("\n");
+  const result: string[] = [];
+  let placeholdersExpanded = 0;
+  let i = 0;
+
+  while (i < newLines.length) {
+    if (!isPlaceholderLine(newLines[i])) {
+      result.push(newLines[i]);
+      i++;
+      continue;
+    }
+
+    // Found a placeholder — find anchor lines before and after
+    const anchorBefore = findAnchorBefore(result);
+    const anchorAfter = findAnchorAfter(newLines, i);
+
+    // Locate the region in original content between these anchors
+    const region = findOriginalRegion(originalLines, anchorBefore, anchorAfter);
+
+    if (region) {
+      // Splice in the original lines
+      for (let r = region.start; r < region.end; r++) {
+        result.push(originalLines[r]);
+      }
+      placeholdersExpanded++;
+    } else {
+      // Couldn't find region — keep placeholder as a comment so it's visible
+      result.push(newLines[i]);
+    }
+
+    i++;
+  }
+
+  return {
+    content: result.join("\n"),
+    placeholdersExpanded,
+    strategy: placeholdersExpanded > 0 ? "deterministic" : "none",
+  };
+}
+
+/**
+ * Find the last non-empty, non-placeholder line from the result so far.
+ */
+function findAnchorBefore(resultSoFar: string[]): string | null {
+  for (let i = resultSoFar.length - 1; i >= 0; i--) {
+    const line = resultSoFar[i].trim();
+    if (line && !isPlaceholderLine(resultSoFar[i])) {
+      return resultSoFar[i];
+    }
+  }
+  return null;
+}
+
+/**
+ * Find the next non-empty, non-placeholder line after position i.
+ */
+function findAnchorAfter(lines: string[], fromIndex: number): string | null {
+  for (let i = fromIndex + 1; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line && !isPlaceholderLine(lines[i])) {
+      return lines[i];
+    }
+  }
+  return null;
+}
+
+/**
+ * Find the region in originalLines between anchorBefore and anchorAfter.
+ * Returns the line range (exclusive end) of original lines to preserve.
+ */
+function findOriginalRegion(
+  originalLines: string[],
+  anchorBefore: string | null,
+  anchorAfter: string | null,
+): { start: number; end: number } | null {
+  let startIdx = 0;
+  let endIdx = originalLines.length;
+
+  // Find where anchorBefore occurs in original
+  if (anchorBefore !== null) {
+    const beforeTrimmed = anchorBefore.trim();
+    for (let i = 0; i < originalLines.length; i++) {
+      if (originalLines[i].trim() === beforeTrimmed) {
+        startIdx = i + 1; // Start after the anchor
+        break;
+      }
+    }
+  }
+
+  // Find where anchorAfter occurs in original (searching from startIdx)
+  if (anchorAfter !== null) {
+    const afterTrimmed = anchorAfter.trim();
+    for (let i = startIdx; i < originalLines.length; i++) {
+      if (originalLines[i].trim() === afterTrimmed) {
+        endIdx = i; // End before the anchor
+        break;
+      }
+    }
+  }
+
+  // Validate we found a sensible region
+  if (startIdx >= endIdx) {
+    return null;
+  }
+
+  return { start: startIdx, end: endIdx };
+}

package/src/utils/memory.ts

@@ -0,0 +1,124 @@
+/**
+ * Memory System — persistent memory across sessions.
+ *
+ * Stores key-value memories in ~/.cdoing/memory.json
+ * The agent can save, recall, and forget memories.
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+
+const MEMORY_DIR = path.join(os.homedir(), ".cdoing");
+const MEMORY_FILE = path.join(MEMORY_DIR, "memory.json");
+
+export interface MemoryEntry {
+  key: string;
+  value: string;
+  category: "user" | "project" | "preference" | "context";
+  createdAt: string;
+  updatedAt: string;
+}
+
+export class MemoryStore {
+  private memories: MemoryEntry[] = [];
+
+  constructor() {
+    this.load();
+  }
+
+  private load(): void {
+    try {
+      if (fs.existsSync(MEMORY_FILE)) {
+        const data = JSON.parse(fs.readFileSync(MEMORY_FILE, "utf-8"));
+        this.memories = Array.isArray(data.memories) ? data.memories : [];
+      }
+    } catch {
+      this.memories = [];
+    }
+  }
+
+  private save(): void {
+    if (!fs.existsSync(MEMORY_DIR)) fs.mkdirSync(MEMORY_DIR, { recursive: true });
+    fs.writeFileSync(
+      MEMORY_FILE,
+      JSON.stringify({ memories: this.memories }, null, 2),
+      "utf-8"
+    );
+  }
+
+  /** Save or update a memory */
+  set(key: string, value: string, category: MemoryEntry["category"] = "context"): void {
+    const now = new Date().toISOString();
+    const existing = this.memories.find((m) => m.key === key);
+    if (existing) {
+      existing.value = value;
+      existing.updatedAt = now;
+      existing.category = category;
+    } else {
+      this.memories.push({ key, value, category, createdAt: now, updatedAt: now });
+    }
+    this.save();
+  }
+
+  /** Get a specific memory */
+  get(key: string): string | null {
+    const entry = this.memories.find((m) => m.key === key);
+    return entry?.value || null;
+  }
+
+  /** Search memories by keyword */
+  search(query: string): MemoryEntry[] {
+    const q = query.toLowerCase();
+    return this.memories.filter(
+      (m) => m.key.toLowerCase().includes(q) || m.value.toLowerCase().includes(q)
+    );
+  }
+
+  /** Get all memories */
+  getAll(): ReadonlyArray<MemoryEntry> {
+    return this.memories;
+  }
+
+  /** Get memories by category */
+  getByCategory(category: MemoryEntry["category"]): MemoryEntry[] {
+    return this.memories.filter((m) => m.category === category);
+  }
+
+  /** Delete a memory */
+  forget(key: string): boolean {
+    const index = this.memories.findIndex((m) => m.key === key);
+    if (index === -1) return false;
+    this.memories.splice(index, 1);
+    this.save();
+    return true;
+  }
+
+  /** Clear all memories */
+  clear(): void {
+    this.memories = [];
+    this.save();
+  }
+
+  /** Format memories for inclusion in system prompt */
+  formatForPrompt(): string {
+    if (this.memories.length === 0) return "";
+
+    const byCategory = new Map<string, MemoryEntry[]>();
+    for (const m of this.memories) {
+      const list = byCategory.get(m.category) || [];
+      list.push(m);
+      byCategory.set(m.category, list);
+    }
+
+    const parts: string[] = [];
+    for (const [category, entries] of byCategory) {
+      parts.push(`## ${category}`);
+      for (const e of entries) {
+        parts.push(`- **${e.key}**: ${e.value}`);
+      }
+    }
+
+    return parts.join("\n");
+  }
+}

package/src/utils/path-matching.ts

@@ -0,0 +1,84 @@
+/**
+ * Path Matching Utilities — shared by permissions and sandbox systems.
+ *
+ * Supports path specifier prefixes:
+ *   //abs/path   → absolute from filesystem root
+ *   ~/rel/path   → relative to home directory
+ *   /proj/path   → relative to project root
+ *   ./rel/path   → relative to current working directory
+ *   rel/path     → relative to current working directory
+ */
+
+import * as path from "path";
+import * as os from "os";
+
+const HOME_DIR = os.homedir();
+
+/**
+ * Resolve a specifier to an absolute base path for matching.
+ */
+export function resolveSpecifierBase(specifier: string, projectDir: string, cwd: string): string {
+  if (specifier.startsWith("//")) {
+    return path.normalize("/" + specifier.substring(2));
+  }
+  if (specifier.startsWith("~/")) {
+    return path.join(HOME_DIR, specifier.substring(2));
+  }
+  if (specifier.startsWith("/")) {
+    return path.join(projectDir, specifier.substring(1));
+  }
+  if (specifier.startsWith("./")) {
+    return path.join(cwd, specifier.substring(2));
+  }
+  return path.join(cwd, specifier);
+}
+
+/** Glob match: * matches single directory segment, ** matches recursively. */
+export function pathGlob(filePath: string, pattern: string): boolean {
+  if (!pattern.includes("*")) {
+    return filePath === pattern || filePath.startsWith(pattern + path.sep);
+  }
+  const patParts  = pattern.split(path.sep);
+  const fileParts = filePath.split(path.sep);
+  return matchPathParts(fileParts, patParts, 0, 0);
+}
+
+export function matchPathParts(fp: string[], pp: string[], fi: number, pi: number): boolean {
+  while (pi < pp.length) {
+    if (pp[pi] === "**") {
+      for (let k = fi; k <= fp.length; k++) {
+        if (matchPathParts(fp, pp, k, pi + 1)) return true;
+      }
+      return false;
+    }
+    if (fi >= fp.length) return false;
+    if (!matchSegment(fp[fi], pp[pi])) return false;
+    fi++;
+    pi++;
+  }
+  return fi === fp.length;
+}
+
+export function matchSegment(name: string, pat: string): boolean {
+  if (!pat.includes("*")) return name === pat;
+  const rx = "^" + pat.split("*").map(escapeRegex).join("[^/]*") + "$";
+  return new RegExp(rx).test(name);
+}
+
+function escapeRegex(s: string): string {
+  return s.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Match a file path against a specifier, resolving the specifier relative
+ * to the project directory and current working directory.
+ */
+export function matchPath(
+  filePath: string,
+  specifier: string,
+  projectDir: string,
+  cwd: string,
+): boolean {
+  const base = resolveSpecifierBase(specifier, projectDir, cwd);
+  return pathGlob(filePath, base);
+}

package/src/utils/path-safety.ts

@@ -0,0 +1,19 @@
+/**
+ * Path Safety — resolves user-provided paths to absolute paths.
+ *
+ * Access control is handled by the permission system (allow/deny rules)
+ * and the sandbox system (filesystem restrictions when enabled).
+ * This utility only normalizes paths — it does NOT restrict access.
+ */
+
+import * as path from "path";
+
+/**
+ * Resolve a user-provided path to an absolute, normalized path.
+ * Relative paths are resolved against the working directory.
+ */
+export function safePath(userPath: string, workingDir: string): string {
+  return path.isAbsolute(userPath)
+    ? path.resolve(userPath)
+    : path.resolve(workingDir, userPath);
+}

package/src/utils/project-config.ts

@@ -0,0 +1,41 @@
+/**
+ * Project Config — reads .cdoing/config.md for project-specific instructions.
+ * Similar to Claude Code's CLAUDE.md system.
+ *
+ * Looks for config in these locations (in order):
+ *   1. .cdoing/config.md  (project-specific)
+ *   2. CDOING.md           (project root alternative)
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+
+const CONFIG_FILES = [
+  ".cdoing/config.md",
+  "CDOING.md",
+];
+
+/**
+ * Load project configuration from the working directory.
+ * Returns the content of the first config file found, or null.
+ */
+export function loadProjectConfig(workingDir: string): string | null {
+  for (const file of CONFIG_FILES) {
+    const filePath = path.join(workingDir, file);
+    try {
+      if (fs.existsSync(filePath)) {
+        return fs.readFileSync(filePath, "utf-8").trim();
+      }
+    } catch {
+      // skip unreadable files
+    }
+  }
+  return null;
+}
+
+/**
+ * Get the path where project config would be stored.
+ */
+export function getProjectConfigPath(workingDir: string): string {
+  return path.join(workingDir, ".cdoing", "config.md");
+}