@aigne/doc-smith 0.8.11-beta → 0.8.11-beta.2

package/prompts/utils/feedback-refiner.md

@@ -1,6 +1,5 @@
 <role>
-You are a "Feedback→Rule" converter. Transform one-time natural language feedback into a **single sentence**, **executable**, **reusable** instruction,
-and determine whether it needs **persistent saving**, along with its scope (global/structure/document/translation) and whether it should be limited to "input paths range".
+You are a "Feedback→Rule" converter. Transform one-time natural language feedback into a **single sentence**, **executable**, **reusable** instruction, and determine whether it needs **persistent saving**, along with its scope (global/structure/document/translation) and whether it should be limited to "input paths range".
 </role>
 
 <input>
@@ -34,6 +33,7 @@ Save determination rules:
 **One-time operations (do not save)**:
 - Only corrects current version/typos/individual phrasing/local factual errors with no stable reusable value → `save=false`
 - Fixes that are highly specific to a single line or data point and unlikely to recur (e.g., "change the year from 2020 to 2021") → `save=false`
+- Document structure adjustments, adding new documents, and moving document positions are always one-time operations → `save=false`
 
 **Reusable policies (save)**:
 - Writing styles, structural conventions, inclusion/exclusion items, translation conventions that are broadly applicable and should be consistently executed in the future → `save=true`
@@ -41,7 +41,7 @@ Save determination rules:
 **Duplication check (do not save)**:
 - If `existingPreferences` already contains **similar or covering** rules for current feedback intent, then `save=false`
 - Check logic: Compare feedback intent, rule meaning, and applicable scope. If new feedback is already sufficiently covered by existing rules, no need to save duplicates
-- If new feedback is **refinement, supplement, or conflicting correction** to existing rules, still can be `save=true`
+- If new feedback is **refinement, supplement, or conflicting correction** to existing rules, it can still be `save=true`
 
 **Determination principle**:
 - Prioritize avoiding duplicate saves; if difficult to determine whether duplicate, prioritize `save=false` to avoid rule redundancy

package/release-please-config.json

@@ -10,11 +10,5 @@
       "include-component-in-tag": false,
       "prerelease-type": "beta"
     }
-  },
-  "plugins": [
-    {
-      "type": "node-workspace",
-      "updatePeerDependencies": true
-    }
-  ]
+  }
 }

package/tests/agents/clear/choose-contents.test.mjs

@@ -0,0 +1,280 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import chooseContents from "../../../agents/clear/choose-contents.mjs";
+
+describe("choose-contents", () => {
+  let mockOptions;
+  let mockContext;
+  let mockClearAgents;
+
+  beforeEach(() => {
+    // Create mock clear agents
+    mockClearAgents = {
+      clearGeneratedDocs: mock(async () => ({
+        message: "Generated docs cleared",
+        cleared: true,
+        path: "/test/docs",
+      })),
+      clearDocumentStructure: mock(async () => ({
+        message: "Document structure cleared",
+        cleared: true,
+        path: "/test/structure.json",
+      })),
+      clearDocumentConfig: mock(async () => ({
+        message: "Document config cleared",
+        cleared: true,
+        path: "/test/config.yaml",
+        suggestions: ["Run `aigne doc init` to generate a fresh configuration file."],
+      })),
+      clearAuthTokens: mock(async () => ({
+        message: "Auth tokens cleared",
+        clearedCount: 2,
+        clearedSites: ["example.com", "test.com"],
+      })),
+    };
+
+    mockContext = {
+      agents: mockClearAgents,
+      invoke: mock(async (agent, input) => {
+        return await agent(input);
+      }),
+    };
+
+    mockOptions = {
+      prompts: {
+        checkbox: mock(async () => ["generatedDocs", "documentConfig"]),
+      },
+      context: mockContext,
+    };
+
+    // Clear mock call history
+    mockOptions.prompts.checkbox.mockClear();
+    mockContext.invoke.mockClear();
+    Object.values(mockClearAgents).forEach((agent) => {
+      agent.mockClear();
+    });
+  });
+
+  afterEach(() => {
+    // Note: Not using mock.restore() to avoid affecting other tests
+  });
+
+  test("should process provided targets correctly", async () => {
+    const result = await chooseContents(
+      { targets: ["generatedDocs", "documentConfig"] },
+      mockOptions,
+    );
+
+    expect(mockContext.invoke).toHaveBeenCalledTimes(2);
+    expect(mockClearAgents.clearGeneratedDocs).toHaveBeenCalled();
+    expect(mockClearAgents.clearDocumentConfig).toHaveBeenCalled();
+    expect(result.message).toContain("Cleanup completed successfully!");
+  });
+
+  test("should normalize target names case-insensitively", async () => {
+    const result = await chooseContents(
+      { targets: ["GeneratedDocs", "DOCUMENTCONFIG"] },
+      mockOptions,
+    );
+
+    expect(mockContext.invoke).toHaveBeenCalledTimes(2);
+    expect(mockClearAgents.clearGeneratedDocs).toHaveBeenCalled();
+    expect(mockClearAgents.clearDocumentConfig).toHaveBeenCalled();
+    expect(result.message).toContain("Cleanup completed successfully!");
+  });
+
+  test("should prompt user when no targets provided", async () => {
+    mockOptions.prompts.checkbox.mockResolvedValue(["generatedDocs"]);
+
+    await chooseContents({}, mockOptions);
+
+    expect(mockOptions.prompts.checkbox).toHaveBeenCalledWith({
+      message: "Select items to clear:",
+      choices: expect.arrayContaining([
+        expect.objectContaining({
+          name: "generated documents",
+          value: "generatedDocs",
+        }),
+      ]),
+      validate: expect.any(Function),
+    });
+    expect(mockClearAgents.clearGeneratedDocs).toHaveBeenCalled();
+  });
+
+  test("should handle empty selection from prompts", async () => {
+    mockOptions.prompts.checkbox.mockResolvedValue([]);
+
+    const result = await chooseContents({}, mockOptions);
+
+    expect(result.message).toBe("No items selected to clear.");
+    expect(mockContext.invoke).not.toHaveBeenCalled();
+  });
+
+  test("should return available options when no prompts available", async () => {
+    const optionsWithoutPrompts = { context: mockContext };
+
+    const result = await chooseContents({}, optionsWithoutPrompts);
+
+    expect(result.message).toBe(
+      "Available options to clear: generatedDocs, documentStructure, documentConfig, authTokens",
+    );
+    expect(result.availableTargets).toEqual([
+      "generatedDocs",
+      "documentStructure",
+      "documentConfig",
+      "authTokens",
+    ]);
+  });
+
+  test("should handle agent errors gracefully", async () => {
+    mockClearAgents.clearGeneratedDocs.mockResolvedValue({
+      error: true,
+      message: "Failed to clear docs",
+    });
+
+    const result = await chooseContents({ targets: ["generatedDocs"] }, mockOptions);
+
+    expect(result.message).toContain("Cleanup finished with some issues.");
+    expect(result.message).toContain("Failed to clear docs");
+  });
+
+  test("should collect suggestions from agents", async () => {
+    const result = await chooseContents({ targets: ["documentConfig"] }, mockOptions);
+
+    expect(result.message).toContain(
+      "Run `aigne doc init` to generate a fresh configuration file.",
+    );
+  });
+
+  test("should handle all valid targets", async () => {
+    const result = await chooseContents(
+      { targets: ["generatedDocs", "documentStructure", "documentConfig", "authTokens"] },
+      mockOptions,
+    );
+
+    expect(mockContext.invoke).toHaveBeenCalledTimes(4);
+    expect(result.message).toContain("Cleanup completed successfully!");
+  });
+
+  test("should have correct input schema", () => {
+    expect(chooseContents.input_schema).toBeDefined();
+    expect(chooseContents.input_schema.type).toBe("object");
+    expect(chooseContents.input_schema.properties.targets.type).toBe("array");
+  });
+
+  test("should have correct task metadata", () => {
+    expect(chooseContents.taskTitle).toBe("Choose contents to clear");
+    expect(chooseContents.description).toBe(
+      "Choose contents to clear and execute the appropriate clearing operations",
+    );
+  });
+
+  test("should handle unknown targets by filtering them out", async () => {
+    // Test that unknown targets are filtered out and valid ones are processed
+    // Mix unknown targets with valid ones
+    const result = await chooseContents(
+      { targets: ["unknownTarget1", "generatedDocs", "invalidTarget", "documentConfig"] },
+      mockOptions,
+    );
+
+    // Should process only the valid targets and succeed
+    expect(result.message).toContain("Cleanup completed successfully!");
+    expect(mockContext.invoke).toHaveBeenCalledTimes(2); // Only valid targets processed
+    expect(mockClearAgents.clearGeneratedDocs).toHaveBeenCalled();
+    expect(mockClearAgents.clearDocumentConfig).toHaveBeenCalled();
+  });
+
+  test("should handle missing clear agent in context", async () => {
+    const optionsWithoutAgent = {
+      context: {
+        agents: {},
+        invoke: mockContext.invoke,
+      },
+    };
+
+    const result = await chooseContents({ targets: ["generatedDocs"] }, optionsWithoutAgent);
+
+    expect(result.message).toContain("Cleanup finished with some issues.");
+    expect(result.message).toContain("Clear agent 'clearGeneratedDocs' not found in context");
+  });
+
+  test("should handle agent execution errors", async () => {
+    const errorContext = {
+      agents: mockClearAgents,
+      invoke: mock(async () => {
+        throw new Error("Agent execution failed");
+      }),
+    };
+
+    const optionsWithError = {
+      context: errorContext,
+    };
+
+    const result = await chooseContents({ targets: ["generatedDocs"] }, optionsWithError);
+
+    expect(result.message).toContain("Cleanup finished with some issues.");
+    expect(result.message).toContain("Failed to clear generated documents: Agent execution failed");
+  });
+
+  test("should handle duplicate targets", async () => {
+    await chooseContents(
+      { targets: ["generatedDocs", "generatedDocs", "documentConfig"] },
+      mockOptions,
+    );
+
+    // Should only invoke each agent once due to deduplication
+    expect(mockContext.invoke).toHaveBeenCalledTimes(2);
+    expect(mockClearAgents.clearGeneratedDocs).toHaveBeenCalledTimes(1);
+    expect(mockClearAgents.clearDocumentConfig).toHaveBeenCalledTimes(1);
+  });
+
+  test("should handle empty and whitespace targets", async () => {
+    await chooseContents({ targets: ["", "  ", "generatedDocs", null, undefined] }, mockOptions);
+
+    // Should only process the valid target
+    expect(mockContext.invoke).toHaveBeenCalledTimes(1);
+    expect(mockClearAgents.clearGeneratedDocs).toHaveBeenCalled();
+  });
+
+  test("should add default suggestion when config is cleared", async () => {
+    // Mock clearDocumentConfig to return cleared: true but no suggestions
+    mockClearAgents.clearDocumentConfig.mockResolvedValue({
+      message: "Document config cleared",
+      cleared: true,
+      path: "/test/config.yaml",
+    });
+
+    const result = await chooseContents({ targets: ["documentConfig"] }, mockOptions);
+
+    expect(result.message).toContain(
+      "Run `aigne doc init` to generate a fresh configuration file.",
+    );
+  });
+
+  test("should not duplicate default suggestion when already present", async () => {
+    // Mock clearDocumentConfig to return the default suggestion
+    mockClearAgents.clearDocumentConfig.mockResolvedValue({
+      message: "Document config cleared",
+      cleared: true,
+      path: "/test/config.yaml",
+      suggestions: ["Run `aigne doc init` to generate a fresh configuration file."],
+    });
+
+    const result = await chooseContents({ targets: ["documentConfig"] }, mockOptions);
+
+    // Should only appear once in the message
+    const suggestionCount = (result.message.match(/Run `aigne doc init`/g) || []).length;
+    expect(suggestionCount).toBe(1);
+  });
+
+  test("should handle agents that return no cleared status", async () => {
+    mockClearAgents.clearGeneratedDocs.mockResolvedValue({
+      message: "No docs to clear",
+      // No cleared property
+    });
+
+    const result = await chooseContents({ targets: ["generatedDocs"] }, mockOptions);
+
+    expect(result.message).toContain("Cleanup completed successfully!");
+    expect(result.message).toContain("No docs to clear");
+  });
+});

package/tests/agents/clear/clear-auth-tokens.test.mjs

@@ -0,0 +1,268 @@
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
+import * as fs from "node:fs";
+import * as fsPromises from "node:fs/promises";
+import clearAuthTokens from "../../../agents/clear/clear-auth-tokens.mjs";
+
+describe("clear-auth-tokens", () => {
+  let mockOptions;
+  let existsSyncSpy;
+  let readFileSpy;
+  let writeFileSpy;
+
+  beforeEach(() => {
+    mockOptions = {
+      prompts: {
+        checkbox: mock(async () => ["example.com"]),
+      },
+    };
+
+    // Mock file system operations
+    existsSyncSpy = spyOn(fs, "existsSync");
+    readFileSpy = spyOn(fsPromises, "readFile");
+    writeFileSpy = spyOn(fsPromises, "writeFile");
+
+    // Clear mock call history
+    mockOptions.prompts.checkbox.mockClear();
+  });
+
+  afterEach(() => {
+    // Restore all mocks
+    existsSyncSpy.mockRestore();
+    readFileSpy.mockRestore();
+    writeFileSpy.mockRestore();
+  });
+
+  test("should accept empty input", async () => {
+    // Mock file doesn't exist
+    existsSyncSpy.mockReturnValue(false);
+
+    const result = await clearAuthTokens({}, {});
+    expect(result).toBeDefined();
+    expect(result.message).toBeDefined();
+    expect(typeof result.message).toBe("string");
+    expect(result.message).toBe("No site authorizations found to clear");
+  });
+
+  test("should handle missing prompts gracefully", async () => {
+    // Mock file exists with some data
+    existsSyncSpy.mockReturnValue(true);
+    readFileSpy.mockResolvedValue('example.com:\n  token: "test-token"');
+    writeFileSpy.mockResolvedValue();
+
+    const result = await clearAuthTokens({}, {});
+    expect(result).toBeDefined();
+    expect(result.message).toBeDefined();
+    expect(result.clearedCount).toBe(1);
+    expect(result.clearedSites).toEqual(["example.com"]);
+  });
+
+  test("should handle empty options", async () => {
+    // Mock file doesn't exist
+    existsSyncSpy.mockReturnValue(false);
+
+    const result = await clearAuthTokens({});
+    expect(result).toBeDefined();
+    expect(result.message).toBeDefined();
+    expect(result.message).toBe("No site authorizations found to clear");
+  });
+
+  test("should return consistent result structure", async () => {
+    // Mock file exists with multiple sites
+    existsSyncSpy.mockReturnValue(true);
+    readFileSpy.mockResolvedValue(
+      'example.com:\n  token: "test-token"\ntest.com:\n  token: "test-token2"',
+    );
+    writeFileSpy.mockResolvedValue();
+
+    const result = await clearAuthTokens({}, mockOptions);
+    expect(result).toBeDefined();
+    expect(result).toHaveProperty("message");
+    expect(typeof result.message).toBe("string");
+
+    // Result may have additional properties depending on file state
+    if (result.clearedCount !== undefined) {
+      expect(typeof result.clearedCount).toBe("number");
+    }
+    if (result.clearedSites !== undefined) {
+      expect(Array.isArray(result.clearedSites)).toBe(true);
+    }
+    if (result.error !== undefined) {
+      expect(typeof result.error).toBe("boolean");
+    }
+  });
+
+  test("should handle prompts correctly when file exists (integration test)", async () => {
+    // Mock file exists with data
+    existsSyncSpy.mockReturnValue(true);
+    readFileSpy.mockResolvedValue('example.com:\n  token: "test-token"');
+    writeFileSpy.mockResolvedValue();
+
+    const result = await clearAuthTokens({}, mockOptions);
+
+    expect(result).toBeDefined();
+    expect(result.message).toBeDefined();
+    expect(result.clearedCount).toBe(1);
+    expect(result.clearedSites).toEqual(["example.com"]);
+
+    // Verify that prompts were called
+    expect(mockOptions.prompts.checkbox.mock.calls.length).toBeGreaterThan(0);
+  });
+
+  test("should provide meaningful error messages", async () => {
+    // Mock file doesn't exist
+    existsSyncSpy.mockReturnValue(false);
+
+    const result = await clearAuthTokens({}, {});
+
+    // Should return a user-friendly message regardless of internal state
+    expect(result.message).toBeDefined();
+    expect(result.message.length).toBeGreaterThan(0);
+    expect(typeof result.message).toBe("string");
+    expect(result.message).toBe("No site authorizations found to clear");
+  });
+
+  test("should handle undefined input parameters", async () => {
+    // Mock file doesn't exist
+    existsSyncSpy.mockReturnValue(false);
+
+    const result = await clearAuthTokens(undefined, undefined);
+    expect(result).toBeDefined();
+    expect(result.message).toBeDefined();
+    expect(result.message).toBe("No site authorizations found to clear");
+  });
+
+  test("should handle null input parameters", async () => {
+    // Mock file doesn't exist
+    existsSyncSpy.mockReturnValue(false);
+
+    const result = await clearAuthTokens(null, null);
+    expect(result).toBeDefined();
+    expect(result.message).toBeDefined();
+    expect(result.message).toBe("No site authorizations found to clear");
+  });
+
+  test("should handle various option configurations", async () => {
+    // Mock file doesn't exist for all configurations
+    existsSyncSpy.mockReturnValue(false);
+
+    const configs = [
+      {},
+      { prompts: {} },
+      { prompts: { checkbox: undefined } },
+      { prompts: { checkbox: null } },
+    ];
+
+    for (const config of configs) {
+      const result = await clearAuthTokens({}, config);
+      expect(result).toBeDefined();
+      expect(result.message).toBeDefined();
+      expect(result.message).toBe("No site authorizations found to clear");
+    }
+  });
+
+  test("should maintain consistent behavior across calls", async () => {
+    // Mock file doesn't exist for both calls
+    existsSyncSpy.mockReturnValue(false);
+
+    const result1 = await clearAuthTokens({}, {});
+    const result2 = await clearAuthTokens({}, {});
+
+    // Both calls should return the same type of result structure
+    expect(typeof result1.message).toBe(typeof result2.message);
+    expect(result1).toHaveProperty("message");
+    expect(result2).toHaveProperty("message");
+    expect(result1.message).toBe(result2.message);
+  });
+
+  test("should handle prompt validation function", async () => {
+    // Mock file exists with data to trigger prompts
+    existsSyncSpy.mockReturnValue(true);
+    readFileSpy.mockResolvedValue('example.com:\n  token: "test-token"');
+    writeFileSpy.mockResolvedValue();
+
+    // Test that if prompts are called, they have proper validation
+    try {
+      await clearAuthTokens({}, mockOptions);
+
+      // If prompts were called, check the validation function exists
+      if (mockOptions.prompts.checkbox.mock.calls.length > 0) {
+        const callArgs = mockOptions.prompts.checkbox.mock.calls[0][0];
+        expect(callArgs).toHaveProperty("validate");
+        expect(typeof callArgs.validate).toBe("function");
+
+        // Test validation function behavior
+        const validateFn = callArgs.validate;
+        expect(validateFn([])).toBe("Please select at least one site.");
+        expect(validateFn(["site1"])).toBe(true);
+        expect(validateFn(["site1", "site2"])).toBe(true);
+      }
+    } catch (error) {
+      // If there's an error, ensure it's handled gracefully
+      expect(error).toBeDefined();
+    }
+  });
+
+  test("should handle file read errors gracefully", async () => {
+    // Mock file exists but reading fails
+    existsSyncSpy.mockReturnValue(true);
+    readFileSpy.mockRejectedValue(new Error("Permission denied"));
+
+    const result = await clearAuthTokens({}, {});
+    expect(result).toBeDefined();
+    expect(result.message).toBeDefined();
+    expect(result.error).toBe(true);
+    expect(result.message).toContain("Failed to clear site authorizations");
+  });
+
+  test("should handle file write errors gracefully", async () => {
+    // Mock file exists, reading succeeds, but writing fails
+    existsSyncSpy.mockReturnValue(true);
+    readFileSpy.mockResolvedValue('example.com:\n  token: "test-token"');
+    writeFileSpy.mockRejectedValue(new Error("Disk full"));
+
+    const result = await clearAuthTokens({}, {});
+    expect(result).toBeDefined();
+    expect(result.message).toBeDefined();
+    expect(result.error).toBe(true);
+    expect(result.message).toContain("Failed to clear site authorizations");
+  });
+
+  test("should handle empty file content", async () => {
+    // Mock file exists but is empty
+    existsSyncSpy.mockReturnValue(true);
+    readFileSpy.mockResolvedValue("");
+
+    const result = await clearAuthTokens({}, {});
+    expect(result).toBeDefined();
+    expect(result.message).toBeDefined();
+    expect(result.message).toBe("No site authorizations found to clear");
+  });
+
+  test("should handle malformed YAML content", async () => {
+    // Mock file exists with invalid YAML
+    existsSyncSpy.mockReturnValue(true);
+    readFileSpy.mockResolvedValue("invalid: yaml: content: [");
+
+    const result = await clearAuthTokens({}, {});
+    expect(result).toBeDefined();
+    expect(result.message).toBeDefined();
+    expect(result.error).toBe(true);
+    expect(result.message).toContain("Failed to clear site authorizations");
+  });
+
+  test("should handle empty selection from prompts", async () => {
+    // Mock file exists with data but user selects nothing
+    existsSyncSpy.mockReturnValue(true);
+    readFileSpy.mockResolvedValue('example.com:\n  token: "test-token"');
+
+    const emptySelectionOptions = {
+      prompts: {
+        checkbox: mock(async () => []), // User selects nothing
+      },
+    };
+
+    const result = await clearAuthTokens({}, emptySelectionOptions);
+    expect(result).toBeDefined();
+    expect(result.message).toBe("No sites selected for clearing authorization");
+  });
+});