wdyt 0.1.11 → 0.1.15

package/src/context/symbols.ts

@@ -0,0 +1,234 @@
+/**
+ * Symbol extraction module for wdyt
+ *
+ * Extracts function names, class names, type definitions, and interface names
+ * from source files in multiple languages.
+ */
+
+/** Symbol types that can be extracted from source code */
+export type SymbolType = "function" | "class" | "type" | "interface" | "const";
+
+/** Extracted symbol information */
+export interface Symbol {
+  name: string;
+  type: SymbolType;
+  line: number;
+}
+
+/** Language-specific regex patterns for symbol extraction */
+interface LanguagePatterns {
+  patterns: Array<{
+    regex: RegExp;
+    type: SymbolType;
+  }>;
+}
+
+/**
+ * TypeScript/JavaScript patterns
+ * Matches: export function, async function, class, type, interface, const
+ */
+const TYPESCRIPT_PATTERNS: LanguagePatterns = {
+  patterns: [
+    {
+      regex: /(?:export\s+)?(?:async\s+)?function\s+(\w+)/g,
+      type: "function",
+    },
+    {
+      regex: /(?:export\s+)?class\s+(\w+)/g,
+      type: "class",
+    },
+    {
+      regex: /(?:export\s+)?type\s+(\w+)/g,
+      type: "type",
+    },
+    {
+      regex: /(?:export\s+)?interface\s+(\w+)/g,
+      type: "interface",
+    },
+    {
+      // Match const with optional type annotation: const FOO: Type = or const FOO =
+      regex: /(?:export\s+)?const\s+(\w+)(?:\s*:\s*[^=]+)?\s*=/g,
+      type: "const",
+    },
+  ],
+};
+
+/**
+ * Python patterns
+ * Matches: def, async def, class (including indented methods)
+ */
+const PYTHON_PATTERNS: LanguagePatterns = {
+  patterns: [
+    {
+      // Match def at any indentation level (for methods inside classes)
+      // Use [ \t]* for horizontal whitespace only (not newlines)
+      regex: /^[ \t]*(?:async\s+)?def\s+(\w+)/gm,
+      type: "function",
+    },
+    {
+      regex: /^class\s+(\w+)/gm,
+      type: "class",
+    },
+  ],
+};
+
+/**
+ * Go patterns
+ * Matches: func, type struct, type interface
+ */
+const GO_PATTERNS: LanguagePatterns = {
+  patterns: [
+    {
+      regex: /^func\s+(?:\([^)]+\)\s+)?(\w+)/gm,
+      type: "function",
+    },
+    {
+      regex: /^type\s+(\w+)\s+struct/gm,
+      type: "class",
+    },
+    {
+      regex: /^type\s+(\w+)\s+interface/gm,
+      type: "interface",
+    },
+  ],
+};
+
+/**
+ * Rust patterns
+ * Matches: fn, pub fn, struct, pub struct, trait, pub trait, impl, type alias
+ */
+const RUST_PATTERNS: LanguagePatterns = {
+  patterns: [
+    {
+      regex: /(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/g,
+      type: "function",
+    },
+    {
+      regex: /(?:pub\s+)?struct\s+(\w+)/g,
+      type: "class",
+    },
+    {
+      regex: /(?:pub\s+)?trait\s+(\w+)/g,
+      type: "interface",
+    },
+    {
+      // Match type alias with optional generic params: type Foo<T> = or type Foo =
+      regex: /(?:pub\s+)?type\s+(\w+)(?:<[^>]*>)?\s*=/g,
+      type: "type",
+    },
+  ],
+};
+
+/** File extensions to language pattern mapping */
+const EXTENSION_PATTERNS: Record<string, LanguagePatterns> = {
+  ".ts": TYPESCRIPT_PATTERNS,
+  ".tsx": TYPESCRIPT_PATTERNS,
+  ".js": TYPESCRIPT_PATTERNS,
+  ".jsx": TYPESCRIPT_PATTERNS,
+  ".mjs": TYPESCRIPT_PATTERNS,
+  ".cjs": TYPESCRIPT_PATTERNS,
+  ".py": PYTHON_PATTERNS,
+  ".go": GO_PATTERNS,
+  ".rs": RUST_PATTERNS,
+};
+
+/**
+ * Get the file extension from a file path
+ */
+function getExtension(filePath: string): string {
+  const lastDot = filePath.lastIndexOf(".");
+  if (lastDot === -1) return "";
+  return filePath.slice(lastDot).toLowerCase();
+}
+
+/**
+ * Get line number for a given character index in content
+ */
+function getLineNumber(content: string, charIndex: number): number {
+  let lineNumber = 1;
+  for (let i = 0; i < charIndex && i < content.length; i++) {
+    if (content[i] === "\n") {
+      lineNumber++;
+    }
+  }
+  return lineNumber;
+}
+
+/**
+ * Extract symbols from file content
+ *
+ * @param content - The source file content
+ * @param filePath - The file path (used to determine language from extension)
+ * @returns Array of extracted symbols with name, type, and line number
+ */
+export function extractSymbols(content: string, filePath: string): Symbol[] {
+  const extension = getExtension(filePath);
+  const languagePatterns = EXTENSION_PATTERNS[extension];
+
+  if (!languagePatterns) {
+    return [];
+  }
+
+  const symbols: Symbol[] = [];
+  const seen = new Set<string>();
+
+  for (const { regex, type } of languagePatterns.patterns) {
+    // Reset regex lastIndex for global patterns
+    regex.lastIndex = 0;
+
+    let match: RegExpExecArray | null;
+    while ((match = regex.exec(content)) !== null) {
+      const name = match[1];
+      const key = `${name}:${type}:${match.index}`;
+
+      // Avoid duplicates at the same position
+      if (seen.has(key)) continue;
+      seen.add(key);
+
+      symbols.push({
+        name,
+        type,
+        line: getLineNumber(content, match.index),
+      });
+    }
+  }
+
+  // Sort by line number
+  symbols.sort((a, b) => a.line - b.line);
+
+  return symbols;
+}
+
+/**
+ * Extract symbols from a file path
+ *
+ * @param filePath - Absolute path to the source file
+ * @returns Array of extracted symbols
+ */
+export async function extractSymbolsFromFile(
+  filePath: string
+): Promise<Symbol[]> {
+  const file = Bun.file(filePath);
+
+  if (!(await file.exists())) {
+    return [];
+  }
+
+  const content = await file.text();
+  return extractSymbols(content, filePath);
+}
+
+/**
+ * Check if a file extension is supported for symbol extraction
+ */
+export function isSupported(filePath: string): boolean {
+  const extension = getExtension(filePath);
+  return extension in EXTENSION_PATTERNS;
+}
+
+/**
+ * Get list of supported file extensions
+ */
+export function getSupportedExtensions(): string[] {
+  return Object.keys(EXTENSION_PATTERNS);
+}

package/src/flow/index.ts

@@ -0,0 +1,18 @@
+/**
+ * Flow module exports
+ *
+ * Provides Flow-Next task spec loading and related utilities.
+ */
+
+export {
+  parseTaskId,
+  getEpicId,
+  isTaskId,
+  getSpecPath,
+  loadTaskSpec,
+  formatSpecXml,
+  getTaskSpecContext,
+  extractTaskIdFromPayload,
+  type TaskSpecResult,
+  type LoadTaskSpecOptions,
+} from "./specs";

package/src/flow/specs.test.ts

@@ -0,0 +1,260 @@
+/**
+ * Tests for Flow-Next spec loading module
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from "bun:test";
+import { mkdirSync, rmSync } from "fs";
+import { join } from "path";
+import {
+  parseTaskId,
+  getEpicId,
+  isTaskId,
+  getSpecPath,
+  loadTaskSpec,
+  formatSpecXml,
+  getTaskSpecContext,
+  extractTaskIdFromPayload,
+} from "./specs";
+
+// Test fixtures
+const TEST_DIR = join(import.meta.dir, "..", "..", ".test-flow");
+const TEST_FLOW_DIR = join(TEST_DIR, ".flow");
+
+// Sample spec content - using valid fn-N or fn-N-suffix ID format
+const SAMPLE_SPEC = `# fn-99-test.1 Test Task
+
+## Description
+This is a test task for unit testing.
+
+### Requirements
+- Requirement 1
+- Requirement 2
+
+### Acceptance Criteria
+- [ ] Criteria 1
+- [ ] Criteria 2
+`;
+
+const SAMPLE_EPIC_SPEC = `# fn-99-test Test Epic
+
+## Overview
+This is a test epic.
+
+## Tasks
+- fn-99-test.1 - Test Task
+`;
+
+describe("parseTaskId", () => {
+  it("parses simple task ID", () => {
+    expect(parseTaskId("fn-1.2")).toBe("fn-1.2");
+  });
+
+  it("parses task ID with suffix", () => {
+    expect(parseTaskId("fn-2-vth.7")).toBe("fn-2-vth.7");
+  });
+
+  it("parses epic ID", () => {
+    expect(parseTaskId("fn-1")).toBe("fn-1");
+  });
+
+  it("parses epic ID with suffix", () => {
+    expect(parseTaskId("fn-2-vth")).toBe("fn-2-vth");
+  });
+
+  it("handles uppercase", () => {
+    expect(parseTaskId("FN-1.2")).toBe("fn-1.2");
+  });
+
+  it("handles whitespace", () => {
+    expect(parseTaskId("  fn-1.2  ")).toBe("fn-1.2");
+  });
+
+  it("rejects invalid formats", () => {
+    expect(parseTaskId("invalid")).toBeNull();
+    expect(parseTaskId("fn1.2")).toBeNull();
+    expect(parseTaskId("fn-")).toBeNull();
+    expect(parseTaskId("")).toBeNull();
+    expect(parseTaskId(null as unknown as string)).toBeNull();
+  });
+});
+
+describe("getEpicId", () => {
+  it("extracts epic from simple task", () => {
+    expect(getEpicId("fn-1.2")).toBe("fn-1");
+  });
+
+  it("extracts epic from task with suffix", () => {
+    expect(getEpicId("fn-2-vth.7")).toBe("fn-2-vth");
+  });
+
+  it("returns epic unchanged", () => {
+    expect(getEpicId("fn-1")).toBe("fn-1");
+  });
+
+  it("returns epic with suffix unchanged", () => {
+    expect(getEpicId("fn-2-vth")).toBe("fn-2-vth");
+  });
+});
+
+describe("isTaskId", () => {
+  it("identifies task IDs", () => {
+    expect(isTaskId("fn-1.2")).toBe(true);
+    expect(isTaskId("fn-2-vth.7")).toBe(true);
+  });
+
+  it("identifies epic IDs", () => {
+    expect(isTaskId("fn-1")).toBe(false);
+    expect(isTaskId("fn-2-vth")).toBe(false);
+  });
+});
+
+describe("getSpecPath", () => {
+  it("returns task spec path", () => {
+    const path = getSpecPath("fn-1.2", { cwd: "/project" });
+    expect(path).toBe("/project/.flow/tasks/fn-1.2.md");
+  });
+
+  it("returns epic spec path", () => {
+    const path = getSpecPath("fn-1", { cwd: "/project" });
+    expect(path).toBe("/project/.flow/specs/fn-1.md");
+  });
+
+  it("uses custom flow directory", () => {
+    const path = getSpecPath("fn-1.2", { flowDir: "/custom/.flow" });
+    expect(path).toBe("/custom/.flow/tasks/fn-1.2.md");
+  });
+});
+
+describe("loadTaskSpec", () => {
+  beforeAll(() => {
+    // Create test directory structure
+    mkdirSync(join(TEST_FLOW_DIR, "tasks"), { recursive: true });
+    mkdirSync(join(TEST_FLOW_DIR, "specs"), { recursive: true });
+
+    // Write test spec files
+    Bun.write(join(TEST_FLOW_DIR, "tasks", "fn-99-test.1.md"), SAMPLE_SPEC);
+    Bun.write(join(TEST_FLOW_DIR, "specs", "fn-99-test.md"), SAMPLE_EPIC_SPEC);
+  });
+
+  afterAll(() => {
+    // Clean up test directory
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  });
+
+  it("loads existing task spec", async () => {
+    const result = await loadTaskSpec("fn-99-test.1", { flowDir: TEST_FLOW_DIR });
+
+    expect(result.found).toBe(true);
+    expect(result.taskId).toBe("fn-99-test.1");
+    expect(result.content).toBe(SAMPLE_SPEC);
+    expect(result.path).toContain("fn-99-test.1.md");
+  });
+
+  it("loads existing epic spec", async () => {
+    const result = await loadTaskSpec("fn-99-test", { flowDir: TEST_FLOW_DIR });
+
+    expect(result.found).toBe(true);
+    expect(result.taskId).toBe("fn-99-test");
+    expect(result.content).toBe(SAMPLE_EPIC_SPEC);
+    expect(result.path).toContain("fn-99-test.md");
+  });
+
+  it("returns not found for missing spec", async () => {
+    const result = await loadTaskSpec("fn-88.99", { flowDir: TEST_FLOW_DIR });
+
+    expect(result.found).toBe(false);
+    expect(result.taskId).toBe("fn-88.99");
+    expect(result.error).toContain("not found");
+  });
+
+  it("returns error for invalid task ID", async () => {
+    const result = await loadTaskSpec("invalid", { flowDir: TEST_FLOW_DIR });
+
+    expect(result.found).toBe(false);
+    expect(result.error).toContain("Invalid task ID");
+  });
+});
+
+describe("formatSpecXml", () => {
+  it("formats found spec as XML", () => {
+    const result = {
+      found: true,
+      taskId: "fn-99-test.1",
+      content: SAMPLE_SPEC,
+    };
+
+    const xml = formatSpecXml(result);
+
+    expect(xml).toContain("<task_spec>");
+    expect(xml).toContain("</task_spec>");
+    expect(xml).toContain("# fn-99-test.1 Test Task");
+  });
+
+  it("returns empty string for not found", () => {
+    const result = {
+      found: false,
+      taskId: "fn-99-test.1",
+      error: "Not found",
+    };
+
+    const xml = formatSpecXml(result);
+    expect(xml).toBe("");
+  });
+});
+
+describe("getTaskSpecContext", () => {
+  beforeAll(() => {
+    // Create test directory structure
+    mkdirSync(join(TEST_FLOW_DIR, "tasks"), { recursive: true });
+    Bun.write(join(TEST_FLOW_DIR, "tasks", "fn-99-test.1.md"), SAMPLE_SPEC);
+  });
+
+  afterAll(() => {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  });
+
+  it("returns formatted XML for existing spec", async () => {
+    const xml = await getTaskSpecContext("fn-99-test.1", { flowDir: TEST_FLOW_DIR });
+
+    expect(xml).toContain("<task_spec>");
+    expect(xml).toContain("# fn-99-test.1 Test Task");
+  });
+
+  it("returns empty string for missing spec (graceful fallback)", async () => {
+    const xml = await getTaskSpecContext("fn-88.99", { flowDir: TEST_FLOW_DIR });
+
+    expect(xml).toBe("");
+  });
+});
+
+describe("extractTaskIdFromPayload", () => {
+  it("extracts task_id field", () => {
+    const payload = { task_id: "fn-1.2" };
+    expect(extractTaskIdFromPayload(payload)).toBe("fn-1.2");
+  });
+
+  it("extracts taskId field", () => {
+    const payload = { taskId: "fn-2-vth.7" };
+    expect(extractTaskIdFromPayload(payload)).toBe("fn-2-vth.7");
+  });
+
+  it("extracts task field", () => {
+    const payload = { task: "fn-1.2" };
+    expect(extractTaskIdFromPayload(payload)).toBe("fn-1.2");
+  });
+
+  it("returns null for missing field", () => {
+    const payload = { other: "value" };
+    expect(extractTaskIdFromPayload(payload)).toBeNull();
+  });
+
+  it("returns null for invalid task ID", () => {
+    const payload = { task_id: "invalid" };
+    expect(extractTaskIdFromPayload(payload)).toBeNull();
+  });
+
+  it("returns null for non-object", () => {
+    expect(extractTaskIdFromPayload(null)).toBeNull();
+    expect(extractTaskIdFromPayload("string")).toBeNull();
+  });
+});