remove rule injection during onboarding

uinstinct · uinstinct · commit 452da6eaf060 · 2025-10-09T11:11:59.000+05:30
diff --git a/extensions/cli/src/config.ts b/extensions/cli/src/config.ts
@@ -7,17 +7,14 @@ import {
 import {
   Configuration,
   DefaultApi,
-  DefaultApiInterface,
 } from "@continuedev/sdk/dist/api/dist/index.js";
 
 import {
   AuthConfig,
   getAccessToken,
   getOrganizationId,
 } from "./auth/workos.js";
-import { loadConfiguration } from "./configLoader.js";
 import { env } from "./env.js";
-import { MCPService } from "./services/MCPService.js";
 
 /**
  * Creates an LLM API instance from a ModelConfig and auth configuration
@@ -96,23 +93,3 @@ export function getApiClient(
     }),
   );
 }
-
-export async function initialize(
-  authConfig: AuthConfig,
-  configPath: string | undefined,
-): Promise<{
-  config: AssistantUnrolled;
-  llmApi: BaseLlmApi;
-  model: ModelConfig;
-  mcpService: MCPService;
-  apiClient: DefaultApiInterface;
-}> {
-  const apiClient = getApiClient(authConfig?.accessToken);
-  const result = await loadConfiguration(authConfig, configPath, apiClient);
-  const config = result.config;
-  const [llmApi, model] = getLlmApi(config, authConfig);
-  const mcpService = new MCPService();
-  await mcpService.initialize(config, false);
-
-  return { config, llmApi, model, mcpService, apiClient };
-}
diff --git a/extensions/cli/src/onboarding.ts b/extensions/cli/src/onboarding.ts
@@ -1,16 +1,10 @@
 import * as fs from "fs";
 import * as path from "path";
 
-import { AssistantUnrolled, ModelConfig } from "@continuedev/config-yaml";
-import { BaseLlmApi } from "@continuedev/openai-adapters";
-import { DefaultApiInterface } from "@continuedev/sdk/dist/api/dist/index.js";
 import chalk from "chalk";
 
-import { AuthConfig, isAuthenticated, login } from "./auth/workos.js";
-import { initialize } from "./config.js";
+import { login } from "./auth/workos.js";
 import { env } from "./env.js";
-import { processRule } from "./hubLoader.js";
-import { MCPService } from "./services/MCPService.js";
 import {
   getApiKeyValidationError,
   isValidAnthropicApiKey,
@@ -20,15 +14,6 @@ import { updateAnthropicModelInYaml } from "./util/yamlConfigUpdater.js";
 
 const CONFIG_PATH = path.join(env.continueHome, "config.yaml");
 
-export interface OnboardingResult {
-  config: AssistantUnrolled;
-  llmApi: BaseLlmApi;
-  model: ModelConfig;
-  mcpService: MCPService;
-  apiClient: DefaultApiInterface;
-  wasOnboarded: boolean;
-}
-
 export async function checkHasAcceptableModel(
   configPath: string,
 ): Promise<boolean> {
@@ -61,21 +46,18 @@ export async function createOrUpdateConfig(apiKey: string): Promise<void> {
 
 export async function runOnboardingFlow(
   configPath: string | undefined,
-  authConfig: AuthConfig,
-): Promise<OnboardingResult> {
+): Promise<boolean> {
   // Step 1: Check if --config flag is provided
   if (configPath !== undefined) {
-    const result = await initialize(authConfig, configPath);
-    return { ...result, wasOnboarded: false };
+    return false;
   }
 
   // Step 2: Check for CONTINUE_USE_BEDROCK environment variable first (before test env check)
   if (process.env.CONTINUE_USE_BEDROCK === "1") {
     console.log(
       chalk.blue("✓ Using AWS Bedrock (CONTINUE_USE_BEDROCK detected)"),
     );
-    const result = await initialize(authConfig, CONFIG_PATH);
-    return { ...result, wasOnboarded: true };
+    return true;
   }
 
   // Step 3: Check if we're in a test/CI environment - if so, skip interactive prompts
@@ -92,13 +74,11 @@ export async function runOnboardingFlow(
       console.log(chalk.blue("✓ Using ANTHROPIC_API_KEY from environment"));
       await createOrUpdateConfig(process.env.ANTHROPIC_API_KEY);
       console.log(chalk.gray(`  Config saved to: ${CONFIG_PATH}`));
-      const result = await initialize(authConfig, CONFIG_PATH);
-      return { ...result, wasOnboarded: false };
+      return false;
     }
 
     // Otherwise return a minimal working configuration
-    const result = await initialize(authConfig, undefined);
-    return { ...result, wasOnboarded: false };
+    return false;
   }
 
   // Step 4: Present user with two options
@@ -114,13 +94,8 @@ export async function runOnboardingFlow(
   );
 
   if (choice === "1" || choice === "") {
-    const newAuthConfig = await login();
-
-    const { ensureOrganization } = await import("./auth/workos.js");
-    const finalAuthConfig = await ensureOrganization(newAuthConfig);
-
-    const result = await initialize(finalAuthConfig, undefined);
-    return { ...result, wasOnboarded: true };
+    await login();
+    return true;
   } else if (choice === "2") {
     const apiKey = await question(
       chalk.white("\nEnter your Anthropic API key: "),
@@ -135,89 +110,12 @@ export async function runOnboardingFlow(
       chalk.green(`✓ Config file updated successfully at ${CONFIG_PATH}`),
     );
 
-    const result = await initialize(authConfig, CONFIG_PATH);
-    return { ...result, wasOnboarded: true };
+    return true;
   } else {
     throw new Error(`Invalid choice. Please select "1" or "2"`);
   }
 }
 
-export async function runNormalFlow(
-  authConfig: AuthConfig,
-  configPath?: string,
-  rules?: string[],
-): Promise<OnboardingResult> {
-  // Step 1: Check if --config flag is provided
-  if (configPath !== undefined) {
-    // Empty string is invalid and should be treated as an error
-    if (configPath === "") {
-      throw new Error(
-        `Failed to load config from "": Config path cannot be empty`,
-      );
-    }
-
-    try {
-      const result = await initialize(authConfig, configPath);
-      // Inject rules into the config if provided
-      if (rules && rules.length > 0) {
-        result.config = await injectRulesIntoConfig(result.config, rules);
-      }
-      return { ...result, wasOnboarded: false };
-    } catch (error) {
-      // If user explicitly provided --config flag, fail loudly instead of falling back
-      const errorMessage =
-        error instanceof Error ? error.message : String(error);
-      throw new Error(
-        `Failed to load config from "${configPath}": ${errorMessage}`,
-      );
-    }
-  }
-
-  // Step 2: If user is logged in, look for first assistant in selected org
-  if (isAuthenticated()) {
-    try {
-      const result = await initialize(authConfig, undefined);
-      // Inject rules into the config if provided
-      if (rules && rules.length > 0) {
-        result.config = await injectRulesIntoConfig(result.config, rules);
-      }
-      return { ...result, wasOnboarded: false };
-    } catch {
-      // Silently ignore errors when loading default assistant
-    }
-  }
-
-  // Step 3: Look for local ~/.continue/config.yaml
-  if (fs.existsSync(CONFIG_PATH)) {
-    try {
-      const result = await initialize(authConfig, CONFIG_PATH);
-      // Inject rules into the config if provided
-      if (rules && rules.length > 0) {
-        result.config = await injectRulesIntoConfig(result.config, rules);
-      }
-      return { ...result, wasOnboarded: false };
-    } catch {
-      console.log(chalk.yellow("⚠ Invalid config file found"));
-    }
-  }
-
-  // Step 4: Look for ANTHROPIC_API_KEY in environment
-  if (process.env.ANTHROPIC_API_KEY) {
-    console.log(chalk.blue("✓ Using ANTHROPIC_API_KEY from environment"));
-    await createOrUpdateConfig(process.env.ANTHROPIC_API_KEY);
-    console.log(chalk.gray(`  Config saved to: ${CONFIG_PATH}`));
-    const result = await initialize(authConfig, CONFIG_PATH);
-    // Inject rules into the config if provided
-    if (rules && rules.length > 0) {
-      result.config = await injectRulesIntoConfig(result.config, rules);
-    }
-    return { ...result, wasOnboarded: false };
-  }
-
-  // Step 5: Fall back to onboarding flow
-  return runOnboardingFlow(configPath, authConfig);
-}
-
 export async function isFirstTime(): Promise<boolean> {
   return !fs.existsSync(path.join(env.continueHome, ".onboarding_complete"));
 }
@@ -233,82 +131,13 @@ export async function markOnboardingComplete(): Promise<void> {
   fs.writeFileSync(flagPath, new Date().toISOString());
 }
 
-/**
- * Process rules and inject them into the assistant config
- * @param config - The assistant config to modify
- * @param rules - Array of rule specifications to process and inject
- * @returns The modified config with injected rules
- */
-async function injectRulesIntoConfig(
-  config: AssistantUnrolled,
-  rules: string[],
-): Promise<AssistantUnrolled> {
-  if (!rules || rules.length === 0) {
-    return config;
-  }
-
-  const processedRules: string[] = [];
-  for (const ruleSpec of rules) {
-    try {
-      const processedRule = await processRule(ruleSpec);
-      processedRules.push(processedRule);
-    } catch (error: any) {
-      console.warn(
-        chalk.yellow(
-          `Warning: Failed to process rule "${ruleSpec}": ${error.message}`,
-        ),
-      );
-    }
-  }
-
-  if (processedRules.length === 0) {
-    return config;
-  }
-
-  // Clone the config to avoid mutating the original
-  const modifiedConfig = { ...config };
-
-  // Add processed rules to the config's rules array
-  // Each processed rule is a string, which is a valid Rule type
-  const existingRules = modifiedConfig.rules || [];
-  modifiedConfig.rules = [...existingRules, ...processedRules];
-
-  return modifiedConfig;
-}
-
-export async function initializeWithOnboarding(
-  authConfig: AuthConfig,
-  configPath: string | undefined,
-  rules?: string[],
-) {
+export async function initializeWithOnboarding(configPath: string | undefined) {
   const firstTime = await isFirstTime();
 
-  if (firstTime) {
-    const onboardingResult = await runOnboardingFlow(configPath, authConfig);
-    if (onboardingResult.wasOnboarded) {
-      await markOnboardingComplete();
-    }
-    // Inject rules into the config if provided (for onboarding flow which doesn't handle rules directly)
-    if (rules && rules.length > 0 && !onboardingResult.wasOnboarded) {
-      onboardingResult.config = await injectRulesIntoConfig(
-        onboardingResult.config,
-        rules,
-      );
-    }
-  } else {
-    // when running normal flow, initialize (remote) config asynchronously
-    void (async () => {
-      const onboardingResult = await runNormalFlow(
-        authConfig,
-        configPath,
-        rules,
-      );
-      if (rules && rules.length > 0) {
-        onboardingResult.config = await injectRulesIntoConfig(
-          onboardingResult.config,
-          rules,
-        );
-      }
-    })();
+  if (!firstTime) return;
+
+  const wasOnboarded = await runOnboardingFlow(configPath);
+  if (wasOnboarded) {
+    await markOnboardingComplete();
   }
 }
diff --git a/extensions/cli/src/services/index.ts b/extensions/cli/src/services/index.ts
@@ -1,4 +1,3 @@
-import { loadAuthConfig } from "../auth/workos.js";
 import { initializeWithOnboarding } from "../onboarding.js";
 import { logger } from "../util/logger.js";
 
@@ -54,12 +53,7 @@ export async function initializeServices(initOptions: ServiceInitOptions = {}) {
 
   // Handle onboarding for TUI mode (headless: false) unless explicitly skipped
   if (!initOptions.headless && !initOptions.skipOnboarding) {
-    const authConfig = loadAuthConfig();
-    await initializeWithOnboarding(
-      authConfig,
-      commandOptions.config,
-      commandOptions.rule,
-    );
+    await initializeWithOnboarding(commandOptions.config);
   }
 
   // Handle ANTHROPIC_API_KEY in headless mode when no config path is provided
