@aigne/doc-smith 0.8.12-beta.5 → 0.8.12-beta.7

package/tests/agents/publish/publish-docs.test.mjs

@@ -446,39 +446,6 @@ describe("publish-docs", () => {
     expect(saveValueToConfigSpy).not.toHaveBeenCalledWith("boardId", expect.anything());
   });
 
-  // ERROR HANDLING TESTS
-  test("should handle failed official access token (null)", async () => {
-    loadConfigFromFileSpy.mockResolvedValue({});
-    getOfficialAccessTokenSpy.mockResolvedValue(null);
-    mockOptions.prompts.select.mockResolvedValue("default");
-
-    const result = await publishDocs(
-      {
-        docsDir: "./docs",
-        appUrl: "https://docsmith.aigne.io",
-      },
-      mockOptions,
-    );
-
-    expect(result.message).toBe("❌ Failed to publish docs: Failed to get official access token");
-  });
-
-  test("should handle failed official access token (undefined)", async () => {
-    loadConfigFromFileSpy.mockResolvedValue({});
-    getOfficialAccessTokenSpy.mockResolvedValue(undefined);
-    mockOptions.prompts.select.mockResolvedValue("default");
-
-    const result = await publishDocs(
-      {
-        docsDir: "./docs",
-        appUrl: "https://docsmith.aigne.io",
-      },
-      mockOptions,
-    );
-
-    expect(result.message).toBe("❌ Failed to publish docs: Failed to get official access token");
-  });
-
   test("should handle checkCacheSession failure", async () => {
     loadConfigFromFileSpy.mockResolvedValue({});
     getOfficialAccessTokenSpy.mockResolvedValue("valid-token");

package/tests/utils/history-utils.test.mjs

@@ -1,14 +1,17 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test, mock, spyOn } from "bun:test";
 import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { DOC_SMITH_DIR } from "../../utils/constants/index.mjs";
-import { getHistory, isGitAvailable, recordUpdate } from "../../utils/history-utils.mjs";
+import { recordUpdate, getHistory } from "../../utils/history-utils.mjs";
 
+// Mock the child_process module
 const TEST_DIR = join(process.cwd(), `${DOC_SMITH_DIR}-test`);
 const ORIGINAL_CWD = process.cwd();
 
-describe("History Utils - Unified", () => {
-  beforeEach(() => {
+describe("History Utils", () => {
+  let execSyncMock;
+
+  beforeEach(async () => {
     // Clean up test directory
     if (existsSync(TEST_DIR)) {
       rmSync(TEST_DIR, { recursive: true });
@@ -17,6 +20,9 @@ describe("History Utils - Unified", () => {
 
     // Change to test directory
     process.chdir(TEST_DIR);
+
+    // Get the mocked execSync
+    execSyncMock = spyOn(await import("node:child_process"), "execSync");
   });
 
   afterEach(() => {
@@ -27,11 +33,8 @@ describe("History Utils - Unified", () => {
     if (existsSync(TEST_DIR)) {
       rmSync(TEST_DIR, { recursive: true });
     }
-  });
 
-  test("detects git availability", () => {
-    const hasGit = isGitAvailable();
-    expect(typeof hasGit).toBe("boolean");
+    mock.restore();
   });
 
   test("skips recording on empty feedback", () => {
@@ -46,133 +49,158 @@ describe("History Utils - Unified", () => {
     expect(history.entries.length).toBe(0);
   });
 
-  test("records update in YAML", () => {
+  test("git not available - write to YAML only", () => {
+    // Mock git as not available
+    execSyncMock.mockImplementation((command) => {
+      if (command === "git --version") {
+        throw new Error("git: command not found");
+      }
+      throw new Error("Unknown command");
+    });
+
+    // Record update
     recordUpdate({
-      operation: "structure_update",
+      operation: "document_update",
       feedback: "Test feedback",
+      documentPath: "/test",
     });
 
+    // Verify YAML record was created
     const history = getHistory();
     expect(history.entries.length).toBe(1);
     expect(history.entries[0].feedback).toBe("Test feedback");
-    expect(history.entries[0].operation).toBe("structure_update");
+    expect(history.entries[0].operation).toBe("document_update");
+    expect(history.entries[0].documentPath).toBe("/test");
     expect(history.entries[0].timestamp).toBeDefined();
-  });
-
-  test("records document path when provided as string", () => {
-    recordUpdate({
-      operation: "document_update",
-      feedback: "Update document",
-      documentPath: "/getting-started",
-    });
 
-    const history = getHistory();
-    expect(history.entries.length).toBe(1);
-    expect(history.entries[0].documentPath).toBe("/getting-started");
+    // Verify no git repository was created
+    const gitDir = join(process.cwd(), DOC_SMITH_DIR, ".git");
+    expect(existsSync(gitDir)).toBe(false);
   });
 
-  test("records single document path for each update", () => {
-    recordUpdate({
-      operation: "document_update",
-      feedback: "Update single document",
-      documentPath: "/getting-started",
+  test("current directory is git repo - skip git integration", () => {
+    // Mock git as available and in repo
+    execSyncMock.mockImplementation((command) => {
+      if (command === "git --version") {
+        return "git version 2.30.0";
+      }
+      if (command === "git rev-parse --is-inside-work-tree") {
+        return "true";
+      }
+      throw new Error("Unknown command");
     });
 
-    const history = getHistory();
-    expect(history.entries.length).toBe(1);
-    expect(history.entries[0].feedback).toBe("Update single document");
-    expect(history.entries[0].documentPath).toBe("/getting-started");
-  });
-
-  test("does not include documentPath field when documentPath is null", () => {
+    // Record update
     recordUpdate({
       operation: "structure_update",
-      feedback: "Update structure",
-      documentPath: null,
+      feedback: "Structure update",
     });
 
+    // Verify YAML record was created
     const history = getHistory();
     expect(history.entries.length).toBe(1);
-    expect(history.entries[0].documentPath).toBeUndefined();
+    expect(history.entries[0].feedback).toBe("Structure update");
+
+    // Verify no new git repository was created (since we're already in a git repo)
+    const gitDir = join(process.cwd(), DOC_SMITH_DIR, ".git");
+    expect(existsSync(gitDir)).toBe(false);
   });
 
-  test("maintains chronological order (newest first)", () => {
-    recordUpdate({ operation: "structure_update", feedback: "First" });
-    // Small delay to ensure different timestamps
-    const now = Date.now();
-    while (Date.now() === now) {
-      // Wait for next millisecond
-    }
-    recordUpdate({ operation: "document_update", feedback: "Second" });
+  test("write YAML records and commit to git", () => {
+    // Ensure the DOC_SMITH_DIR exists
+    const docSmithDir = join(process.cwd(), DOC_SMITH_DIR);
+    mkdirSync(docSmithDir, { recursive: true });
+
+    // Mock git as available but not in repo
+    execSyncMock.mockImplementation((command) => {
+      if (command === "git --version") {
+        return "git version 2.30.0";
+      }
+      if (command === "git rev-parse --is-inside-work-tree") {
+        throw new Error("not a git repository");
+      }
+      if (command === "git init") {
+        return "Initialized empty Git repository";
+      }
+      if (command === 'git add .gitignore && git commit -m "Initialize doc-smith history"') {
+        return "Initial commit";
+      }
+      if (command === "git add docs/ config.yaml preferences.yml history.yaml") {
+        return "Files added";
+      }
+      if (command === "git diff --cached --quiet") {
+        throw new Error("Has changes");
+      }
+      if (command === 'git commit -m "First update"') {
+        return "Commit successful";
+      }
+      if (command === 'git commit -m "Second update"') {
+        return "Commit successful";
+      }
+      throw new Error("Unknown command: ", command);
+    });
 
-    const history = getHistory();
-    expect(history.entries.length).toBe(2);
-    expect(history.entries[0].feedback).toBe("Second");
-    expect(history.entries[1].feedback).toBe("First");
-  });
+    // Record multiple updates - this should trigger git repo creation and commits
+    recordUpdate({
+      operation: "document_update",
+      feedback: "First update",
+      documentPath: "/first",
+    });
 
-  test("handles multiple updates", () => {
-    recordUpdate({ operation: "structure_update", feedback: "Update 1" });
-    recordUpdate({ operation: "document_update", feedback: "Update 2", documentPath: "/home" });
-    recordUpdate({ operation: "document_update", feedback: "Update 3", documentPath: "/about" });
     recordUpdate({
       operation: "translation_update",
-      feedback: "Update 4",
-      documentPath: "/api",
+      feedback: "Second update",
+      documentPath: "/second",
     });
 
+    // Verify YAML records
     const history = getHistory();
-    expect(history.entries.length).toBe(4);
-    expect(history.entries[0].feedback).toBe("Update 4");
-    expect(history.entries[0].documentPath).toBe("/api");
-    expect(history.entries[1].feedback).toBe("Update 3");
-    expect(history.entries[1].documentPath).toBe("/about");
-    expect(history.entries[2].feedback).toBe("Update 2");
-    expect(history.entries[2].documentPath).toBe("/home");
-    expect(history.entries[3].feedback).toBe("Update 1");
+    expect(history.entries.length).toBe(2);
+    expect(history.entries[0].feedback).toBe("Second update"); // Newest first
+    expect(history.entries[1].feedback).toBe("First update");
+
+    // Verify git commands were called
+    expect(execSyncMock).toHaveBeenCalledWith("git --version", { stdio: "ignore" });
+    expect(execSyncMock).toHaveBeenCalledWith("git rev-parse --is-inside-work-tree", {
+      cwd: process.cwd(),
+      stdio: "pipe",
+      encoding: "utf8",
+    });
+    expect(execSyncMock).toHaveBeenCalledWith("git init", {
+      cwd: join(process.cwd(), DOC_SMITH_DIR),
+      stdio: "ignore",
+    });
   });
 
-  test("returns empty history when file does not exist", () => {
-    const history = getHistory();
+  test("query history.yaml - handle various scenarios", () => {
+    // Test empty history
+    let history = getHistory();
     expect(history.entries).toBeDefined();
     expect(history.entries.length).toBe(0);
-  });
 
-  test("handles corrupted history file gracefully", () => {
-    // Create corrupted YAML file
+    // Test corrupted YAML file
     const historyPath = join(process.cwd(), DOC_SMITH_DIR, "history.yaml");
     mkdirSync(join(process.cwd(), DOC_SMITH_DIR), { recursive: true });
-    writeFileSync(historyPath, "invalid: yaml: content: [[[", "utf8");
+    writeFileSync(historyPath, "invalid: yaml: content: 「「「", "utf8");
 
-    const history = getHistory();
+    history = getHistory();
     expect(history.entries).toBeDefined();
     expect(history.entries.length).toBe(0);
-  });
-
-  test(`creates ${DOC_SMITH_DIR} directory if not exists`, () => {
-    recordUpdate({
-      operation: "document_update",
-      feedback: "Test",
-    });
 
-    const docSmithDir = join(process.cwd(), DOC_SMITH_DIR);
-    expect(existsSync(docSmithDir)).toBe(true);
-  });
-
-  test("timestamp is in ISO 8601 format", () => {
-    recordUpdate({
-      operation: "structure_update",
-      feedback: "Test timestamp",
-    });
-
-    const history = getHistory();
-    const timestamp = history.entries[0].timestamp;
-
-    // Validate ISO 8601 format
-    expect(timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
-
-    // Validate it's a valid date
-    const date = new Date(timestamp);
-    expect(date.toISOString()).toBe(timestamp);
+    // Test valid history
+    const validHistory = {
+      entries: [
+        {
+          timestamp: "2023-01-01T00:00:00.000Z",
+          operation: "document_update",
+          feedback: "Valid entry",
+        },
+      ],
+    };
+    writeFileSync(historyPath, JSON.stringify(validHistory), "utf8");
+
+    history = getHistory();
+    expect(history.entries.length).toBe(1);
+    expect(history.entries[0].feedback).toBe("Valid entry");
   });
 });

package/utils/auth-utils.mjs

@@ -157,7 +157,7 @@ export async function getAccessToken(appUrl, ltToken = "") {
  * @param {string} baseUrl - The official service URL
  * @returns {Promise<string>} - The access token
  */
-export async function getOfficialAccessToken(baseUrl) {
+export async function getOfficialAccessToken(baseUrl, openPage = true) {
   // Early parameter validation
   if (!baseUrl) {
     throw new Error("baseUrl parameter is required for getOfficialAccessToken.");
@@ -188,7 +188,7 @@ export async function getOfficialAccessToken(baseUrl) {
   }
 
   // If token is found, return it
-  if (accessToken) {
+  if (accessToken || !openPage) {
     return accessToken;
   }
 

package/utils/file-utils.mjs

@@ -12,7 +12,7 @@ import { INTELLIGENT_SUGGESTION_TOKEN_THRESHOLD } from "./constants/index.mjs";
  * @param {string} dir - Directory path to check
  * @returns {boolean} True if inside a git repository
  */
-function isInGitRepository(dir) {
+export function isInGitRepository(dir) {
   try {
     execSync("git rev-parse --is-inside-work-tree", {
       cwd: dir,

package/utils/history-utils.mjs

@@ -3,6 +3,7 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { parse, stringify } from "yaml";
 import { DOC_SMITH_DIR } from "./constants/index.mjs";
+import { isInGitRepository } from "./file-utils.mjs";
 
 const HISTORY_FILE = "history.yaml";
 
@@ -161,9 +162,8 @@ export function recordUpdate({ operation, feedback, documentPath = null }) {
   // Always record in YAML
   recordUpdateYaml({ operation, feedback, documentPath });
 
-  // Also record in git if available
-  if (isGitAvailable()) {
-    // Initialize git repo on first update if not exists
+  // Also record in git if git is available and not in a git repository
+  if (isGitAvailable() && !isInGitRepository(process.cwd())) {
     ensureGitRepo();
     recordUpdateGit({ feedback });
   } else {

package/agents/update/fs-tools/glob.mjs

@@ -1,184 +0,0 @@
-import fs from "node:fs";
-import fsPromises from "node:fs/promises";
-import path from "node:path";
-
-/**
- * Sorts files by modification time (newest first), then alphabetically
- */
-function sortFilesByModTime(files, basePath) {
-  return files
-    .map((file) => {
-      const fullPath = path.isAbsolute(file) ? file : path.resolve(basePath, file);
-      try {
-        const stats = fs.statSync(fullPath);
-        return {
-          path: file,
-          fullPath,
-          mtime: stats.mtimeMs || 0,
-        };
-      } catch {
-        return {
-          path: file,
-          fullPath,
-          mtime: 0,
-        };
-      }
-    })
-    .sort((a, b) => {
-      // Sort by modification time (newest first), then alphabetically
-      if (b.mtime !== a.mtime) {
-        return b.mtime - a.mtime;
-      }
-      return a.path.localeCompare(b.path);
-    })
-    .map((item) => item.path);
-}
-
-/**
- * Filters out common ignore patterns
- */
-function shouldIgnoreFile(filePath) {
-  const ignorePatterns = [
-    "node_modules",
-    ".git",
-    ".DS_Store",
-    ".vscode",
-    ".idea",
-    "dist",
-    "build",
-    "*.log",
-    "coverage",
-    ".nyc_output",
-    ".cache",
-  ];
-
-  const normalizedPath = filePath.replace(/\\/g, "/");
-
-  return ignorePatterns.some((pattern) => {
-    if (pattern.includes("*")) {
-      // Simple wildcard matching for patterns like "*.log"
-      const regex = new RegExp(pattern.replace(/\*/g, ".*"));
-      return regex.test(path.basename(normalizedPath));
-    } else {
-      // Directory or file name matching
-      return (
-        normalizedPath.includes(`/${pattern}/`) ||
-        normalizedPath.endsWith(`/${pattern}`) ||
-        normalizedPath.startsWith(`${pattern}/`) ||
-        normalizedPath === pattern
-      );
-    }
-  });
-}
-
-export default async function glob({
-  pattern,
-  case_sensitive = false,
-  respect_git_ignore = true,
-  limit = 100,
-}) {
-  let result = [];
-  let error = null;
-  const searchDir = process.cwd();
-
-  try {
-    // Validate required parameters
-    if (!pattern || typeof pattern !== "string" || pattern.trim() === "") {
-      throw new Error("Pattern parameter is required and cannot be empty");
-    }
-
-    // Use Node.js built-in glob
-    const globOptions = {
-      cwd: searchDir,
-      nodir: true, // Only return files, not directories
-      dot: true, // Include hidden files
-    };
-
-    // Note: Node.js fs.glob doesn't support case_sensitive option directly
-    // We'll handle case sensitivity in post-processing if needed
-    const iter = fsPromises.glob(pattern, globOptions);
-    const files = [];
-
-    for await (const file of iter) {
-      if (files.length >= limit) break;
-
-      // Apply ignore filters
-      if (shouldIgnoreFile(file)) {
-        continue;
-      }
-
-      // Handle case sensitivity if needed
-      if (case_sensitive === false) {
-        // Node.js glob is case-sensitive by default on most systems
-        // For case-insensitive matching, we rely on the pattern itself
-        // or the filesystem behavior
-      }
-
-      files.push(file);
-    }
-
-    // Sort files by modification time (newest first)
-    const sortedFiles = sortFilesByModTime(files, searchDir);
-
-    // Build result message
-    let message;
-    if (sortedFiles.length === 0) {
-      message = `No files found matching pattern "${pattern}"`;
-    } else {
-      const fileCount = sortedFiles.length;
-      const truncated = files.length >= limit;
-      message = `Found ${fileCount}${truncated ? "+" : ""} file(s) matching "${pattern}"`;
-      message += ", sorted by modification time (newest first):";
-    }
-
-    result = {
-      files: sortedFiles,
-      count: sortedFiles.length,
-      message,
-      truncated: files.length >= limit,
-    };
-  } catch (err) {
-    error = err;
-    result = {
-      files: [],
-      count: 0,
-      message: `Error during glob search: ${err.message}`,
-      truncated: false,
-    };
-  }
-
-  return {
-    command: "glob",
-    arguments: {
-      pattern,
-      case_sensitive,
-      respect_git_ignore,
-      limit,
-    },
-    result,
-    error: error && { message: error.message },
-  };
-}
-
-glob.input_schema = {
-  type: "object",
-  properties: {
-    pattern: {
-      type: "string",
-      description: 'The glob pattern to match files against (e.g., "**/*.js", "src/**/*.ts")',
-    },
-    case_sensitive: {
-      type: "boolean",
-      description: "Optional: Whether the search should be case-sensitive (defaults to false)",
-    },
-    respect_git_ignore: {
-      type: "boolean",
-      description: "Optional: Whether to respect .gitignore patterns (defaults to true)",
-    },
-    limit: {
-      type: "number",
-      description: "Optional: Maximum number of files to return (defaults to 100)",
-    },
-  },
-  required: ["pattern"],
-};