Merge pull request #5375 from continuedev/pe/rule-tool-globs

feat: add `globs` to create rule tool

Author: Patrick-Erichsen

core/tools/definitions/createRuleBlock.ts

@@ -4,32 +4,35 @@ import { BUILT_IN_GROUP_NAME, BuiltInToolNames } from "../builtIn";
 export const createRuleBlock: Tool = {
   type: "function",
   displayTitle: "Create Rule Block",
-  wouldLikeTo: 'create a rule block for "{{{ rule_name }}}"',
-  isCurrently: 'creating a rule block for "{{{ rule_name }}}"',
-  hasAlready: 'created a rule block for "{{{ rule_name }}}"',
+  wouldLikeTo: 'create a rule block for "{{{ name }}}"',
+  isCurrently: 'creating a rule block for "{{{ name }}}"',
+  hasAlready: 'created a rule block for "{{{ name }}}"',
   readonly: false,
   isInstant: true,
   group: BUILT_IN_GROUP_NAME,
   function: {
     name: BuiltInToolNames.CreateRuleBlock,
     description:
-      "Creates a persistent rule that applies to all future conversations. " +
-      "Use for establishing ongoing code standards or preferences (e.g. 'use named exports', 'follow Google docstrings'). " +
-      "Not for one-time instructions. Rules are stored as YAML in `.continue/rules`.",
+      "Creates a persistent rule for all future conversations. For establishing code standards or preferences that should be applied consistently.",
     parameters: {
       type: "object",
-      required: ["rule_name", "rule_content"],
+      required: ["name", "rule"],
       properties: {
-        rule_name: {
+        name: {
           type: "string",
           description:
             "Short, descriptive name summarizing the rule's purpose (e.g. 'React Standards', 'Type Hints')",
         },
-        rule_content: {
+        rule: {
           type: "string",
           description:
             "Clear, imperative instruction for future code generation (e.g. 'Use named exports', 'Add Python type hints'). Each rule should focus on one specific standard.",
         },
+        globs: {
+          type: "string",
+          description:
+            "Optional file patterns to which this rule applies (e.g. ['**/*.{ts,tsx}'] or ['src/**/*.ts', 'tests/**/*.ts'])",
+        },
       },
     },
   },

core/tools/implementations/createRuleBlock.test.ts

@@ -0,0 +1,78 @@
+import * as YAML from "yaml";
+import { createRuleBlockImpl } from "./createRuleBlock";
+
+// Mock the extras parameter with necessary functions
+const mockIde = {
+  getWorkspaceDirs: jest.fn().mockResolvedValue(["/"]),
+  writeFile: jest.fn().mockResolvedValue(undefined),
+  openFile: jest.fn().mockResolvedValue(undefined),
+};
+
+const mockExtras = {
+  ide: mockIde,
+};
+
+describe("createRuleBlockImpl", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should create a basic rule with name and rule content", async () => {
+    const args = {
+      name: "Test Rule",
+      rule: "Always write tests",
+    };
+
+    const result = await createRuleBlockImpl(args, mockExtras as any);
+
+    // Verify that writeFile was called with the correct YAML
+    expect(mockIde.writeFile).toHaveBeenCalled();
+    const yamlContent = mockIde.writeFile.mock.calls[0][1];
+    const parsedYaml = YAML.parse(yamlContent);
+
+    // Verify the structure of the YAML
+    expect(parsedYaml).toEqual({
+      name: "Test Rule",
+      version: "0.0.1",
+      schema: "v1",
+      rules: [
+        {
+          name: "Test Rule",
+          rule: "Always write tests",
+        },
+      ],
+    });
+  });
+
+  it("should create a rule with glob pattern", async () => {
+    const args = {
+      name: "TypeScript Rule",
+      rule: "Use interfaces for object shapes",
+      globs: "**/*.{ts,tsx}",
+    };
+
+    await createRuleBlockImpl(args, mockExtras as any);
+
+    // Verify the YAML structure with globs
+    const yamlContent = mockIde.writeFile.mock.calls[0][1];
+    const parsedYaml = YAML.parse(yamlContent);
+    expect(parsedYaml.rules[0]).toEqual({
+      name: "TypeScript Rule",
+      rule: "Use interfaces for object shapes",
+      globs: "**/*.{ts,tsx}",
+    });
+  });
+
+  it("should create a filename based on sanitized rule name", async () => {
+    const args = {
+      name: "Special Ch@racters & Spaces",
+      rule: "Handle special characters",
+    };
+
+    await createRuleBlockImpl(args, mockExtras as any);
+
+    // Check that the filename is sanitized
+    const fileUri = mockIde.writeFile.mock.calls[0][0];
+    expect(fileUri).toContain("special-chracters-spaces.yaml");
+  });
+});

core/tools/implementations/createRuleBlock.ts

@@ -4,31 +4,34 @@ import { ToolImpl } from ".";
 import { joinPathsToUri } from "../../util/uri";
 
 export interface CreateRuleBlockArgs {
-  rule_name: string;
-  rule_content: string;
+  name: string;
+  rule: string;
+  globs?: string;
 }
 
 export const createRuleBlockImpl: ToolImpl = async (
   args: CreateRuleBlockArgs,
   extras,
 ) => {
   // Sanitize rule name for use in filename (remove special chars, replace spaces with dashes)
-  const safeRuleName = args.rule_name
+  const safeRuleName = args.name
     .toLowerCase()
     .replace(/[^a-z0-9\s-]/g, "")
     .replace(/\s+/g, "-");
 
+  const ruleObject = {
+    name: args.name,
+    rule: args.rule,
+    ...(args.globs ? { globs: args.globs.trim() } : {}),
+  };
+
   const ruleBlock: ConfigYaml = {
-    name: args.rule_name,
+    name: args.name,
     version: "0.0.1",
-    rules: [
-      // This can be either a string or an object with {name, rule}
-      // Since we want a simple rule, we use the string format
-      args.rule_content,
-    ],
+    schema: "v1",
+    rules: [ruleObject],
   };
 
-  // Convert the rule block to YAML
   const ruleYaml = YAML.stringify(ruleBlock);
 
   const [localContinueDir] = await extras.ide.getWorkspaceDirs();
@@ -44,9 +47,13 @@ export const createRuleBlockImpl: ToolImpl = async (
 
   return [
     {
-      name: "Rule Block Created",
-      description: `Created ${args.rule_name} rule`,
-      content: ruleYaml,
+      name: "New Rule Block",
+      description: "", // No description throws an error in the GUI
+      uri: {
+        type: "file",
+        value: rulesDirUri,
+      },
+      content: "Rule created successfully",
     },
   ];
 };

docs/docs/customize/deep-dives/rules.md

@@ -1,5 +1,5 @@
 ---
-description: Learn how to customize the system prompt with a `.continuerules` file
+description: Rules are used to provide instructions to the model for Chat, Edit, and Agent requests.
 keywords: [rules, .continuerules, system, prompt, message]
 ---
 
@@ -20,9 +20,9 @@ To form the system message, rules are joined with new lines, in the order they a
 Rules can be added to an Assistant on the Continue Hub. Explore available rules [here](https://hub.continue.dev/explore/rules), or [create your own](https://hub.continue.dev/new?type=block&blockType=rules) in the Hub. These blocks are defined using the [`config.yaml` syntax](../../reference.md#rules) and can also be created locally.
 
 :::info Automatically create local rule blocks
-When in Agent mode, you can simply prompt the agent to create a rule for you.
+When in Agent mode, you can simply prompt the agent to create a rule for you using the `builtin_create_rule_block` tool if enabled.
 
-For example, you can say "Create a rule for this", and a rule will be created for you in `~/.continue/rules` based on your conversation.
+For example, you can say "Create a rule for this", and a rule will be created for you in `.continue/rules` based on your conversation.
 :::
 
 ### Syntax

gui/src/pages/gui/ToolCallDiv/index.tsx

@@ -8,9 +8,9 @@ import {
   FolderIcon,
   FolderOpenIcon,
   GlobeAltIcon,
-  ListBulletIcon,
   MagnifyingGlassIcon,
   MapIcon,
+  PencilIcon,
   XMarkIcon,
 } from "@heroicons/react/24/outline";
 import {
@@ -45,7 +45,7 @@ const toolCallIcons: Record<string, ComponentType> = {
   [BuiltInToolNames.ViewDiff]: CodeBracketIcon,
   [BuiltInToolNames.ViewRepoMap]: MapIcon,
   [BuiltInToolNames.ViewSubdirectory]: FolderOpenIcon,
-  [BuiltInToolNames.CreateRuleBlock]: ListBulletIcon,
+  [BuiltInToolNames.CreateRuleBlock]: PencilIcon,
   // EditExistingFile = "builtin_edit_existing_file",
   // CreateNewFile = "builtin_create_new_file",
   // RunTerminalCommand = "builtin_run_terminal_command",