feat: make commit signature configurable

core/index.d.ts

@@ -1787,6 +1787,7 @@ export interface ContinueConfig {
   modelsByRole: Record<ModelRole, ILLM[]>;
   selectedModelByRole: Record<ModelRole, ILLM | null>;
   data?: DataDestination[];
+  disableCommitSignature?: boolean;
 }
 
 export interface BrowserSerializedContinueConfig {

core/util/GlobalContext.ts

@@ -31,6 +31,7 @@ export type GlobalContextType = {
     [profileId: string]: GlobalContextModelSelections;
   };
   cliSelectedModel?: string; // CLI-specific model selection for unauthenticated users
+  disableCommitSignature?: boolean; // CLI-specific setting to disable commit attribution
 
   /**
    * This is needed to handle the case where a JetBrains user has created

docs/cli/overview.mdx

@@ -160,6 +160,32 @@ Store secure credentials for CLI workflows:
 - Share configurations across team members
 - Version control for your AI workflows
 
+## CLI Settings
+
+Continue CLI stores certain user preferences locally to customize your experience:
+
+### Commit Message Attribution
+
+By default, Continue CLI includes an attribution signature in generated commit messages:
+
+```
+Generated with [Continue](https://continue.dev)
+
+Co-Authored-By: Continue <noreply@continue.dev>
+```
+
+If you prefer not to include this attribution, you can disable it using the `/set` command:
+
+```bash
+/set disableCommitSignature true
+```
+
+This setting is stored locally and applies to all CLI usage on your system. To re-enable attribution:
+
+```bash
+/set disableCommitSignature false
+```
+
 ## Common Use Cases
 
 ### TUI Mode Examples

extensions/cli/src/commands/commands.ts

@@ -95,6 +95,11 @@ export const SYSTEM_SLASH_COMMANDS: SystemCommand[] = [
     description: "Set the title for the current session",
     category: "system",
   },
+  {
+    name: "set",
+    description: "Set CLI preferences",
+    category: "system",
+  },
   {
     name: "exit",
     description: "Exit the chat",

extensions/cli/src/slashCommands.test.ts

@@ -77,6 +77,14 @@ vi.mock("path", () => ({
   join: vi.fn((...parts) => parts.join("/")),
 }));
 
+// Mock GlobalContext
+const mockGlobalContextUpdate = vi.fn();
+vi.mock("core/util/GlobalContext.js", () => ({
+  GlobalContext: class {
+    update = mockGlobalContextUpdate;
+  },
+}));
+
 // Mock session functions
 vi.mock("./session.js", () => ({
   getSessionFilePath: vi.fn(
@@ -429,5 +437,69 @@ describe("slashCommands", () => {
         "Analyze the following code for patterns: my code",
       );
     });
+
+    it("should handle /set disableCommitSignature true", async () => {
+      mockGlobalContextUpdate.mockClear();
+
+      const result = await handleSlashCommands(
+        "/set disableCommitSignature true",
+        mockAssistant,
+      );
+
+      expect(result).toBeDefined();
+      expect(result?.output).toContain(
+        "Preference updated: disableCommitSignature = true",
+      );
+      expect(result?.exit).toBe(false);
+      expect(mockGlobalContextUpdate).toHaveBeenCalledWith(
+        "disableCommitSignature",
+        true,
+      );
+    });
+
+    it("should handle /set disableCommitSignature false", async () => {
+      mockGlobalContextUpdate.mockClear();
+
+      const result = await handleSlashCommands(
+        "/set disableCommitSignature false",
+        mockAssistant,
+      );
+
+      expect(result).toBeDefined();
+      expect(result?.output).toContain(
+        "Preference updated: disableCommitSignature = false",
+      );
+      expect(result?.exit).toBe(false);
+      expect(mockGlobalContextUpdate).toHaveBeenCalledWith(
+        "disableCommitSignature",
+        false,
+      );
+    });
+
+    it("should handle /set with unknown preference", async () => {
+      const result = await handleSlashCommands(
+        "/set unknownPreference value",
+        mockAssistant,
+      );
+
+      expect(result).toBeDefined();
+      expect(result?.output).toContain("Unknown preference: unknownPreference");
+      expect(result?.output).toContain("Available preferences:");
+      expect(result?.output).toContain("disableCommitSignature");
+      expect(result?.exit).toBe(false);
+    });
+
+    it("should handle /set with insufficient arguments", async () => {
+      const result = await handleSlashCommands(
+        "/set disableCommitSignature",
+        mockAssistant,
+      );
+
+      expect(result).toBeDefined();
+      expect(result?.output).toContain("Usage: /set <preference> <value>");
+      expect(result?.output).toContain("Available preferences:");
+      expect(result?.output).toContain("disableCommitSignature");
+      expect(result?.exit).toBe(false);
+    });
   });
 });

extensions/cli/src/slashCommands.ts

@@ -1,5 +1,6 @@
 import { type AssistantConfig } from "@continuedev/sdk";
 import chalk from "chalk";
+import { GlobalContext } from "core/util/GlobalContext.js";
 
 import {
   isAuthenticated,
@@ -168,6 +169,50 @@ function handleTitle(args: string[]) {
   }
 }
 
+function handleSet(args: string[]) {
+  posthogService.capture("useSlashCommand", { name: "set" });
+
+  if (args.length < 2) {
+    return {
+      exit: false,
+      output: chalk.yellow(
+        "Usage: /set <preference> <value>\n\nAvailable preferences:\n  disableCommitSignature <true|false> - Control commit message attribution",
+      ),
+    };
+  }
+
+  const [preference, value] = args;
+
+  try {
+    const globalContext = new GlobalContext();
+
+    switch (preference) {
+      case "disableCommitSignature": {
+        const booleanValue = value.toLowerCase() === "true";
+        globalContext.update("disableCommitSignature", booleanValue);
+        return {
+          exit: false,
+          output: chalk.green(
+            `Preference updated: ${preference} = ${booleanValue}`,
+          ),
+        };
+      }
+      default:
+        return {
+          exit: false,
+          output: chalk.yellow(
+            `Unknown preference: ${preference}\n\nAvailable preferences:\n  disableCommitSignature <true|false> - Control commit message attribution`,
+          ),
+        };
+    }
+  } catch (error: any) {
+    return {
+      exit: false,
+      output: chalk.red(`Failed to update preference: ${error.message}`),
+    };
+  }
+}
+
 const commandHandlers: Record<string, CommandHandler> = {
   help: handleHelp,
   clear: () => {
@@ -195,6 +240,7 @@ const commandHandlers: Record<string, CommandHandler> = {
   },
   fork: handleFork,
   title: handleTitle,
+  set: handleSet,
   init: (args, assistant) => {
     posthogService.capture("useSlashCommand", { name: "init" });
     return handleInit(args, assistant);

extensions/cli/src/systemMessage.test.ts

@@ -7,11 +7,19 @@ const { constructSystemMessage } = await import("./systemMessage.js");
 // Mock the service container to avoid "No factory registered for service 'config'" error
 vi.mock("./services/ServiceContainer.js", () => ({
   serviceContainer: {
-    get: vi.fn().mockResolvedValue({ config: { rules: [] } }),
+    get: vi.fn(),
     set: vi.fn(),
   },
 }));
 
+// Mock GlobalContext
+const mockGlobalContextGet = vi.fn((key: string) => undefined);
+vi.mock("core/util/GlobalContext.js", () => ({
+  GlobalContext: class {
+    get = mockGlobalContextGet as any;
+  },
+}));
+
 // Mock processRule to avoid file system operations in tests
 vi.mock("./hubLoader.js", () => ({
   processRule: vi
@@ -21,6 +29,16 @@ vi.mock("./hubLoader.js", () => ({
 
 const PLAN_MODE_STRING = "You are operating in _Plan Mode_";
 
+const { serviceContainer } = await import("./services/ServiceContainer.js");
+const { GlobalContext } = await import("core/util/GlobalContext.js");
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.mocked(serviceContainer.get).mockResolvedValue({ config: { rules: [] } });
+  // Reset GlobalContext mock
+  mockGlobalContextGet.mockReturnValue(undefined);
+});
+
 describe("constructSystemMessage", () => {
   it("should return base system message with rules when additionalRules is provided", async () => {
     const rules = ["These are the rules for the assistant."];
@@ -260,4 +278,35 @@ Rule 3: Third rule`;
       "which means that your goal is to help the user investigate their ideas",
     );
   });
+
+  it("should include commit signature by default in normal mode", async () => {
+    const result = await constructSystemMessage("normal");
+
+    expect(result).toContain("Generated with [Continue]");
+    expect(result).toContain("Co-Authored-By: Continue");
+  });
+
+  it("should not include commit signature when disableCommitSignature is true", async () => {
+    mockGlobalContextGet.mockImplementation((key: string) => {
+      if (key === "disableCommitSignature") return true as any;
+      return undefined;
+    });
+
+    const result = await constructSystemMessage("normal");
+
+    expect(result).not.toContain("Generated with [Continue]");
+    expect(result).not.toContain("Co-Authored-By: Continue");
+  });
+
+  it("should include commit signature when disableCommitSignature is false", async () => {
+    mockGlobalContextGet.mockImplementation((key: string) => {
+      if (key === "disableCommitSignature") return false as any;
+      return undefined;
+    });
+
+    const result = await constructSystemMessage("normal");
+
+    expect(result).toContain("Generated with [Continue]");
+    expect(result).toContain("Co-Authored-By: Continue");
+  });
 });

extensions/cli/src/systemMessage.ts

@@ -2,6 +2,7 @@ import { execSync } from "child_process";
 import * as fs from "fs";
 import * as path from "path";
 
+import { GlobalContext } from "core/util/GlobalContext.js";
 import pkg from "ignore-walk";
 import { Minimatch } from "minimatch";
 
@@ -98,21 +99,24 @@ ${getDirectoryStructure()}
 ${getGitStatus()}
 </context>`;
 
-async function getConfigYamlRules(): Promise<string[]> {
+async function getConfigYamlRules(): Promise<{
+  rules: string[];
+  configState: ConfigServiceState;
+}> {
   const configState = await serviceContainer.get<ConfigServiceState>(
     SERVICE_NAMES.CONFIG,
   );
+  let rules: string[] = [];
   if (configState.config?.rules) {
     // Extract systemMessage from the config if it exists
-    const rules = configState.config.rules;
-    return rules
+    rules = configState.config.rules
       .map((rule) => {
         return typeof rule === "string" ? rule : rule?.rule;
       })
       .filter((rule): rule is string => !!rule);
   }
 
-  return [];
+  return { rules, configState };
 }
 
 /**
@@ -162,7 +166,7 @@ export async function constructSystemMessage(
     }
   }
 
-  const configYamlRules = await getConfigYamlRules();
+  const { rules: configYamlRules } = await getConfigYamlRules();
   processedRules.push(...configYamlRules);
 
   // Construct the comprehensive system message
@@ -173,12 +177,15 @@ export async function constructSystemMessage(
     systemMessage +=
       '\n<context name="planMode">You are operating in _Plan Mode_, which means that your goal is to help the user investigate their ideas and develop a plan before taking action. You only have access to read-only tools and should not attempt to circumvent them to write / delete / create files. For example, it is not acceptable to use the Bash tool to write to files.</context>\n';
   } else {
-    // TODO - make including this coauthor commit configurable
-    systemMessage += `\n<context name="commitSignature">When creating commits using any CLI or tool, include the following in the commit message:
+    const globalContext = new GlobalContext();
+    const disableSignature = globalContext.get("disableCommitSignature" as any);
+    if (!disableSignature) {
+      systemMessage += `\n<context name="commitSignature">When creating commits using any CLI or tool, include the following in the commit message:
 Generated with [Continue](https://continue.dev)
 
 Co-Authored-By: Continue <noreply@continue.dev>
 </context>\n`;
+    }
   }
 
   // In headless mode, add instructions to be concise and only provide final answers

gui/src/redux/thunks/session.ts

@@ -145,14 +145,7 @@ export const loadRemoteSession = createAsyncThunk<
 export const loadLastSession = createAsyncThunk<void, void, ThunkApiType>(
   "session/loadLast",
   async (_, { extra, dispatch, getState }) => {
-    let lastSessionId = getState().session.lastSessionId;
-
-    // const lastSessionResult = await extra.ideMessenger.request("history/list", {
-    //   limit: 1,
-    // });
-    // if (lastSessionResult.status === "success") {
-    //   lastSessionId = lastSessionResult.content.at(0)?.sessionId;
-    // }
+    const lastSessionId = getState().session.lastSessionId;
 
     if (!lastSessionId) {
       dispatch(newSession());