ai-first-cli 1.1.1 → 1.1.2

package/tests/lazyAnalyzer.test.ts

@@ -0,0 +1,230 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  buildMinimalIndex,
+  expandFeatureContext,
+  expandFlowContext,
+  expandFullContext,
+  getLazyIndexState,
+  hasMinimalIndex,
+  loadMinimalIndex,
+  MinimalIndex,
+  LazyIndexState
+} from "../src/core/lazyAnalyzer.js";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+function createTempProjectDir(files: Record<string, string>): string {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "ai-first-lazy-test-"));
+  for (const [filePath, content] of Object.entries(files)) {
+    const fullPath = path.join(tempDir, filePath);
+    const dir = path.dirname(fullPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(fullPath, content);
+  }
+  return tempDir;
+}
+
+describe("Lazy Analyzer", () => {
+  describe("buildMinimalIndex", () => {
+    it("should build minimal index with Stage 1 data", () => {
+      const projectDir = createTempProjectDir({
+        "package.json": '{"name": "test"}',
+        "src/index.js": "export const hello = () => {}",
+        "src/utils.js": "export const util = () => {}"
+      });
+      
+      const aiDir = path.join(projectDir, "ai");
+      fs.mkdirSync(aiDir, { recursive: true });
+      
+      const result = buildMinimalIndex(projectDir, aiDir);
+      
+      expect(result.languages).toBeDefined();
+      expect(result.frameworks).toBeDefined();
+      expect(result.entrypoints).toBeDefined();
+      expect(result.repoMap).toBeDefined();
+      expect(result.generatedAt).toBeDefined();
+      
+      // Check state file
+      const state = getLazyIndexState(aiDir);
+      expect(state?.stage1Complete).toBe(true);
+      expect(state?.stage2Complete).toBe(false);
+      
+      // Check minimal index file
+      expect(hasMinimalIndex(aiDir)).toBe(true);
+      const minimal = loadMinimalIndex(aiDir);
+      expect(minimal?.languages).toBeDefined();
+    });
+
+    it("should create minimal-index.json file", () => {
+      const projectDir = createTempProjectDir({
+        "package.json": '{"name": "test"}',
+        "src/app.js": "const app = {}"
+      });
+      
+      const aiDir = path.join(projectDir, "ai");
+      fs.mkdirSync(aiDir, { recursive: true });
+      
+      buildMinimalIndex(projectDir, aiDir);
+      
+      const indexPath = path.join(aiDir, "minimal-index.json");
+      expect(fs.existsSync(indexPath)).toBe(true);
+      
+      const content = JSON.parse(fs.readFileSync(indexPath, "utf-8"));
+      expect(content.languages).toBeDefined();
+    });
+  });
+
+  describe("expandFeatureContext", () => {
+    it("should expand context for a specific feature", () => {
+      const projectDir = createTempProjectDir({
+        "package.json": '{"name": "test"}',
+        "src/auth/login.js": "export const login = () => {}",
+        "src/auth/logout.js": "export const logout = () => {}"
+      });
+      
+      const aiDir = path.join(projectDir, "ai");
+      fs.mkdirSync(aiDir, { recursive: true });
+      
+      // Build minimal first
+      buildMinimalIndex(projectDir, aiDir);
+      
+      // Expand feature
+      const result = expandFeatureContext(projectDir, aiDir, "auth");
+      
+      expect(result.success).toBe(true);
+      expect(result.files).toBeDefined();
+      
+      // Check state was updated
+      const state = getLazyIndexState(aiDir);
+      expect(state?.featuresExpanded).toContain("auth");
+    });
+  });
+
+  describe("expandFlowContext", () => {
+    it("should expand context for a specific flow", () => {
+      const projectDir = createTempProjectDir({
+        "package.json": '{"name": "test"}',
+        "src/user.js": "import { auth } from './auth'",
+        "src/auth.js": "export const auth = {}"
+      });
+      
+      const aiDir = path.join(projectDir, "ai");
+      fs.mkdirSync(aiDir, { recursive: true });
+      
+      // Build minimal first
+      buildMinimalIndex(projectDir, aiDir);
+      
+      // Expand flow
+      const result = expandFlowContext(projectDir, aiDir, "user");
+      
+      expect(result.success).toBe(true);
+      
+      // Check state was updated
+      const state = getLazyIndexState(aiDir);
+      expect(state?.flowsExpanded).toContain("user");
+    });
+  });
+
+  describe("expandFullContext", () => {
+    it("should expand all context (Stage 2)", () => {
+      const projectDir = createTempProjectDir({
+        "package.json": '{"name": "test"}',
+        "src/index.js": "export const index = () => {}"
+      });
+      
+      const aiDir = path.join(projectDir, "ai");
+      fs.mkdirSync(aiDir, { recursive: true });
+      
+      buildMinimalIndex(projectDir, aiDir);
+      
+      const result = expandFullContext(projectDir, aiDir);
+      
+      expect(result.symbols).toBeDefined();
+      expect(result.dependencies).toBeDefined();
+      expect(result.features).toBeDefined();
+      expect(result.flows).toBeDefined();
+      
+      // Check stage 2 is complete
+      const state = getLazyIndexState(aiDir);
+      expect(state?.stage2Complete).toBe(true);
+    });
+  });
+
+  describe("getLazyIndexState", () => {
+    it("should return null when no state exists", () => {
+      const projectDir = createTempProjectDir({
+        "package.json": "{}"
+      });
+      const aiDir = path.join(projectDir, "ai");
+      
+      const state = getLazyIndexState(aiDir);
+      expect(state).toBeNull();
+    });
+
+    it("should return state when it exists", () => {
+      const projectDir = createTempProjectDir({
+        "package.json": "{}"
+      });
+      const aiDir = path.join(projectDir, "ai");
+      fs.mkdirSync(aiDir, { recursive: true });
+      
+      buildMinimalIndex(projectDir, aiDir);
+      
+      const state = getLazyIndexState(aiDir);
+      expect(state).not.toBeNull();
+      expect(state?.stage1Complete).toBe(true);
+    });
+  });
+
+  describe("hasMinimalIndex", () => {
+    it("should return false when no minimal index exists", () => {
+      const projectDir = createTempProjectDir({
+        "package.json": "{}"
+      });
+      const aiDir = path.join(projectDir, "ai");
+      
+      expect(hasMinimalIndex(aiDir)).toBe(false);
+    });
+
+    it("should return true when minimal index exists", () => {
+      const projectDir = createTempProjectDir({
+        "package.json": "{}"
+      });
+      const aiDir = path.join(projectDir, "ai");
+      fs.mkdirSync(aiDir, { recursive: true });
+      
+      buildMinimalIndex(projectDir, aiDir);
+      
+      expect(hasMinimalIndex(aiDir)).toBe(true);
+    });
+  });
+
+  describe("loadMinimalIndex", () => {
+    it("should return null when no minimal index exists", () => {
+      const projectDir = createTempProjectDir({
+        "package.json": "{}"
+      });
+      const aiDir = path.join(projectDir, "ai");
+      
+      const index = loadMinimalIndex(aiDir);
+      expect(index).toBeNull();
+    });
+
+    it("should load minimal index when it exists", () => {
+      const projectDir = createTempProjectDir({
+        "package.json": "{}"
+      });
+      const aiDir = path.join(projectDir, "ai");
+      fs.mkdirSync(aiDir, { recursive: true });
+      
+      buildMinimalIndex(projectDir, aiDir);
+      
+      const index = loadMinimalIndex(aiDir);
+      expect(index).not.toBeNull();
+      expect(index?.repoMap).toBeDefined();
+    });
+  });
+});

package/tests/schema.test.ts

@@ -0,0 +1,203 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  generateSchema,
+  generateProject,
+  generateTools,
+  generateAllSchema,
+  loadSchema,
+  loadProject,
+  loadTools,
+  loadFullSchema,
+  isCompatible,
+  validateSchema,
+  SCHEMA_VERSION,
+  GENERATED_BY
+} from "../src/core/schema.js";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+function createTempAiDir(): string {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "ai-first-schema-test-"));
+  const aiDir = path.join(tempDir, "ai");
+  fs.mkdirSync(aiDir, { recursive: true });
+  return aiDir;
+}
+
+describe("Schema System", () => {
+  describe("generateSchema", () => {
+    it("should generate schema.json with correct version", () => {
+      const aiDir = createTempAiDir();
+      const schema = generateSchema(aiDir);
+      
+      expect(schema.schemaVersion).toBe(SCHEMA_VERSION);
+      expect(schema.generatedBy).toBe(GENERATED_BY);
+      expect(schema.generatedAt).toBeDefined();
+      
+      // Verify file was created
+      const schemaPath = path.join(aiDir, "schema.json");
+      expect(fs.existsSync(schemaPath)).toBe(true);
+      
+      const loaded = JSON.parse(fs.readFileSync(schemaPath, "utf-8"));
+      expect(loaded.schemaVersion).toBe(SCHEMA_VERSION);
+    });
+  });
+
+  describe("generateProject", () => {
+    it("should generate project.json with project info", () => {
+      const aiDir = createTempAiDir();
+      const rootDir = "/test/project";
+      
+      const project = generateProject(rootDir, aiDir, {
+        name: "test-project",
+        features: ["auth", "users"],
+        flows: ["login", "register"],
+        languages: ["TypeScript"],
+        frameworks: ["Express"]
+      });
+      
+      expect(project.name).toBe("test-project");
+      expect(project.rootDir).toBe(rootDir);
+      expect(project.features).toEqual(["auth", "users"]);
+      expect(project.flows).toEqual(["login", "register"]);
+      expect(project.languages).toEqual(["TypeScript"]);
+      expect(project.frameworks).toEqual(["Express"]);
+      expect(project.generatedAt).toBeDefined();
+      
+      const projectPath = path.join(aiDir, "project.json");
+      expect(fs.existsSync(projectPath)).toBe(true);
+    });
+
+    it("should auto-detect features from context directory", () => {
+      const aiDir = createTempAiDir();
+      const rootDir = "/test/project";
+      
+      // Create features directory with files
+      const featuresDir = path.join(aiDir, "context", "features");
+      fs.mkdirSync(featuresDir, { recursive: true });
+      fs.writeFileSync(path.join(featuresDir, "auth.json"), "{}");
+      fs.writeFileSync(path.join(featuresDir, "users.json"), "{}");
+      
+      const project = generateProject(rootDir, aiDir);
+      expect(project.features).toContain("auth");
+      expect(project.features).toContain("users");
+    });
+  });
+
+  describe("generateTools", () => {
+    it("should generate tools.json with compatible agents", () => {
+      const aiDir = createTempAiDir();
+      const tools = generateTools(aiDir);
+      
+      expect(tools.compatibleAgents).toContain("opencode");
+      expect(tools.compatibleAgents).toContain("cursor");
+      expect(tools.schemaVersion).toBe(SCHEMA_VERSION);
+      
+      const toolsPath = path.join(aiDir, "tools.json");
+      expect(fs.existsSync(toolsPath)).toBe(true);
+    });
+  });
+
+  describe("generateAllSchema", () => {
+    it("should generate all schema files at once", () => {
+      const aiDir = createTempAiDir();
+      const rootDir = "/test/project";
+      
+      const result = generateAllSchema(rootDir, aiDir, {
+        projectName: "full-test"
+      });
+      
+      expect(result.schema).toBeDefined();
+      expect(result.project).toBeDefined();
+      expect(result.tools).toBeDefined();
+      
+      expect(fs.existsSync(path.join(aiDir, "schema.json"))).toBe(true);
+      expect(fs.existsSync(path.join(aiDir, "project.json"))).toBe(true);
+      expect(fs.existsSync(path.join(aiDir, "tools.json"))).toBe(true);
+    });
+  });
+
+  describe("loadSchema", () => {
+    it("should load schema from existing file", () => {
+      const aiDir = createTempAiDir();
+      generateSchema(aiDir);
+      
+      const loaded = loadSchema(aiDir);
+      expect(loaded).not.toBeNull();
+      expect(loaded?.schemaVersion).toBe(SCHEMA_VERSION);
+    });
+
+    it("should return null for missing schema", () => {
+      const aiDir = createTempAiDir();
+      const loaded = loadSchema(aiDir);
+      expect(loaded).toBeNull();
+    });
+  });
+
+  describe("loadFullSchema", () => {
+    it("should load all schema files", () => {
+      const aiDir = createTempAiDir();
+      generateAllSchema("/test", aiDir);
+      
+      const full = loadFullSchema(aiDir);
+      expect(full).not.toBeNull();
+      expect(full?.schema).toBeDefined();
+      expect(full?.project).toBeDefined();
+      expect(full?.tools).toBeDefined();
+    });
+
+    it("should return null if any file is missing", () => {
+      const aiDir = createTempAiDir();
+      generateSchema(aiDir);
+      
+      const full = loadFullSchema(aiDir);
+      expect(full).toBeNull();
+    });
+  });
+
+  describe("isCompatible", () => {
+    it("should return true for same major version", () => {
+      expect(isCompatible("1.0")).toBe(true);
+      expect(isCompatible("1.5")).toBe(true);
+    });
+
+    it("should return false for different major version", () => {
+      expect(isCompatible("2.0")).toBe(false);
+      expect(isCompatible("0.9")).toBe(false);
+    });
+  });
+
+  describe("validateSchema", () => {
+    it("should validate complete schema", () => {
+      const aiDir = createTempAiDir();
+      generateAllSchema("/test", aiDir);
+      
+      const result = validateSchema(aiDir);
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("should detect missing files", () => {
+      const aiDir = createTempAiDir();
+      
+      const result = validateSchema(aiDir);
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+
+    it("should detect incompatible version", () => {
+      const aiDir = createTempAiDir();
+      generateAllSchema("/test", aiDir);
+      
+      // Manually write incompatible version
+      const schemaPath = path.join(aiDir, "schema.json");
+      const schema = JSON.parse(fs.readFileSync(schemaPath, "utf-8"));
+      schema.schemaVersion = "99.0.0";
+      fs.writeFileSync(schemaPath, JSON.stringify(schema));
+      
+      const result = validateSchema(aiDir);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.includes("Incompatible"))).toBe(true);
+    });
+  });
+});