@git.zone/tsdoc 2.0.4 → 2.0.6

package/ts/aidocs_classes/readme.ts

@@ -1,8 +1,12 @@
 import type { AiDoc } from '../classes.aidoc.js';
 import * as plugins from '../plugins.js';
-import * as paths from '../paths.js';
 import { ProjectContext } from './projectcontext.js';
 import { logger } from '../logging.js';
+import { createReadOnlyFileSystemTools } from '../helpers.agenttools.js';
+
+const getLegalInfo = (smartconfigJson: any): string | undefined => {
+  return smartconfigJson?.['@git.zone/tsdoc']?.legal ?? smartconfigJson?.tsdoc?.legal;
+};
 
 export class Readme {
   // INSTANCE
@@ -19,17 +23,16 @@ export class Readme {
 
     // First check legal info before introducing any cost
     const projectContext = new ProjectContext(this.projectDir);
-    const smartconfigJson = JSON.parse(
-      (await projectContext.gatherFiles()).smartfilesSmartconfigJSON.contents.toString()
-    );
-    const legalInfo = smartconfigJson?.['tsdoc']?.legal;
+    const smartconfigFile = (await projectContext.gatherFiles()).smartfilesSmartconfigJSON;
+    const smartconfigJson = smartconfigFile.contents.length > 0
+      ? JSON.parse(smartconfigFile.contents.toString())
+      : {};
+    const legalInfo = getLegalInfo(smartconfigJson);
     if (!legalInfo) {
-      const error = new Error(`No legal information found in .smartconfig.json`);
-      console.log(error);
+      throw new Error('No legal information found in .smartconfig.json under @git.zone/tsdoc.legal or tsdoc.legal.');
     }
 
-    // Use runAgent with filesystem tool for agent-driven exploration
-    const fsTools = plugins.smartagentTools.filesystemTool({ rootDir: this.projectDir });
+    const fsTools = createReadOnlyFileSystemTools(this.projectDir);
 
     const readmeSystemPrompt = `
 You create markdown READMEs for npm projects. You only output the markdown readme.
@@ -42,7 +45,7 @@ IMPORTANT RULES:
 - README must follow proper markdown format
 - Must contain Install and Usage sections
 - Code examples must use correct TypeScript/ESM syntax
-- Documentation must be comprehensive and helpful
+- Documentation must be comprehensive and helpful without unnecessary filler
 - Do NOT include licensing information (added separately)
 - Do NOT use CommonJS syntax - only ESM
 - Do NOT include "in conclusion" or similar filler
@@ -56,7 +59,7 @@ Use the filesystem tools to explore the project and understand what it does:
 2. Read package.json to understand the package name, description, and dependencies
 3. Read the existing readme.md if it exists (use it as a base, improve and expand)
 4. Read readme.hints.md if it exists (contains hints for documentation)
-5. Read key source files in ts/ directory to understand the API and implementation
+5. Read key source files in ts/ and ts_web/ directories to understand the API and implementation
 6. Focus on exported classes, interfaces, and functions
 
 Then generate a comprehensive README following this template:
@@ -74,7 +77,7 @@ Then generate a comprehensive README following this template:
   Make sure to show a complete set of features of the module.
   Don't omit use cases.
   ALWAYS USE ESM SYNTAX AND TYPESCRIPT.
-  Write at least 4000 words. More if necessary.
+  Size the documentation to the actual project. Do not pad with filler.
   If there is already a readme, take the Usage section as base. Remove outdated content, expand and improve.
   Check for completeness.
   Don't include any licensing information. This will be added later.
@@ -84,12 +87,14 @@ Then generate a comprehensive README following this template:
 
     logger.log('info', 'Starting README generation with agent...');
 
-    const readmeResult = await plugins.smartagent.runAgent({
-      model: this.aiDocsRef.model,
+    const readmeResult = await this.aiDocsRef.runAgent({
+      taskName: 'readme',
+      projectDir: this.projectDir,
       prompt: readmeTaskPrompt,
       system: readmeSystemPrompt,
       tools: fsTools,
       maxSteps: 25,
+      useCompaction: true,
       onToolCall: (toolName) => logger.log('info', `[README] Tool call: ${toolName}`),
     });
 
@@ -110,19 +115,19 @@ Then generate a comprehensive README following this template:
 
     // lets care about monorepo aspects
     const tsPublishInstance = new plugins.tspublish.TsPublish();
-    const subModules = await tsPublishInstance.getModuleSubDirs(paths.cwd);
+    const subModules = await tsPublishInstance.getModuleSubDirs(this.projectDir);
     logger.log('info', `Found ${Object.keys(subModules).length} sub modules`);
 
     for (const subModule of Object.keys(subModules)) {
       logger.log('info', `Building readme for ${subModule}`);
 
-      const subModulePath = plugins.path.join(paths.cwd, subModule);
+      const subModulePath = plugins.path.join(this.projectDir, subModule);
       const tspublishData = await plugins.fsInstance
         .file(plugins.path.join(subModulePath, 'tspublish.json'))
         .encoding('utf8')
         .read();
 
-      const subModuleFsTools = plugins.smartagentTools.filesystemTool({ rootDir: subModulePath });
+      const subModuleFsTools = createReadOnlyFileSystemTools(subModulePath);
 
       const subModuleSystemPrompt = `
 You create markdown READMEs for npm projects. You only output the markdown readme.
@@ -130,7 +135,7 @@ You create markdown READMEs for npm projects. You only output the markdown readm
 IMPORTANT RULES:
 - Only READ files within the submodule directory
 - Do NOT write, delete, or modify any files
-- README must be comprehensive, well-formatted markdown with ESM TypeScript examples
+- README must be comprehensive, well-formatted markdown with ESM TypeScript examples and no filler
 - Do NOT include licensing information (added separately)
 `;
 
@@ -159,7 +164,7 @@ Generate a README following the template:
 [
   Code examples with complete features.
   ESM TypeScript syntax only.
-  Write at least 4000 words.
+  Size the documentation to the submodule. Do not pad with filler.
   No licensing information.
   No "in conclusion".
 ]
@@ -167,12 +172,14 @@ Generate a README following the template:
 Don't use \`\`\` at the beginning or end. Only for code blocks.
 `;
 
-      const subModuleResult = await plugins.smartagent.runAgent({
-        model: this.aiDocsRef.model,
+      const subModuleResult = await this.aiDocsRef.runAgent({
+        taskName: `readme:${subModule}`,
+        projectDir: subModulePath,
         prompt: subModulePrompt,
         system: subModuleSystemPrompt,
         tools: subModuleFsTools,
         maxSteps: 20,
+        useCompaction: true,
         onToolCall: (toolName) => logger.log('info', `[README:${subModule}] Tool call: ${toolName}`),
       });
 

package/ts/classes.aidoc.ts

@@ -1,6 +1,118 @@
 import * as plugins from './plugins.js';
 
 import * as aiDocsClasses from './aidocs_classes/index.js';
+import { logger } from './logging.js';
+
+export type TAiDocAuthMode = 'auto' | 'chatgpt' | 'apiKey';
+
+export interface IAiDocConfig {
+  provider?: plugins.smartai.TProvider;
+  model?: string;
+  authMode?: TAiDocAuthMode;
+  chatGptAuthSources?: plugins.smartaiOpenAiChatGptAuth.TOpenAiChatGptAuthSource[];
+  chatGptAuthWriteBack?: Partial<Record<plugins.smartaiOpenAiChatGptAuth.TOpenAiChatGptAuthSource, boolean>>;
+  providerOptions?: plugins.smartai.TSmartAiProviderOptions;
+  cache?: plugins.smartagent.TAgentCacheSetting;
+  promptCaching?: boolean | plugins.smartai.ISmartAiCacheOptions;
+  apiKey?: string;
+  baseUrl?: string;
+  ollamaOptions?: plugins.smartai.IOllamaModelOptions;
+}
+
+export interface IAiDocResolvedConfig extends Required<Pick<IAiDocConfig,
+  'provider' | 'model' | 'authMode' | 'chatGptAuthSources'
+>> {
+  chatGptAuthWriteBack: Partial<Record<plugins.smartaiOpenAiChatGptAuth.TOpenAiChatGptAuthSource, boolean>>;
+  providerOptions?: plugins.smartai.TSmartAiProviderOptions;
+  cache: plugins.smartagent.TAgentCacheSetting;
+  promptCaching?: boolean | plugins.smartai.ISmartAiCacheOptions;
+  apiKey?: string;
+  baseUrl?: string;
+  ollamaOptions?: plugins.smartai.IOllamaModelOptions;
+}
+
+export const defaultAiDocConfig: IAiDocResolvedConfig = {
+  provider: 'openai',
+  model: 'gpt-5.5',
+  authMode: 'auto',
+  chatGptAuthSources: ['opencode', 'codex', 'smartai'],
+  chatGptAuthWriteBack: {
+    smartai: true,
+    opencode: false,
+    codex: false,
+  },
+  providerOptions: {
+    openai: {
+      reasoningEffort: 'xhigh',
+    },
+  },
+  cache: 'auto',
+};
+
+const isPlainObject = (value: unknown): value is Record<string, any> => {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+
+const mergeProviderOptions = (
+  base?: plugins.smartai.TSmartAiProviderOptions,
+  override?: plugins.smartai.TSmartAiProviderOptions,
+): plugins.smartai.TSmartAiProviderOptions | undefined => {
+  if (!base && !override) return undefined;
+  const result: Record<string, any> = { ...(base ?? {}) };
+  for (const [provider, options] of Object.entries(override ?? {})) {
+    result[provider] = {
+      ...(isPlainObject(result[provider]) ? result[provider] : {}),
+      ...(isPlainObject(options) ? options : {}),
+    };
+  }
+  return result as plugins.smartai.TSmartAiProviderOptions;
+};
+
+const normalizeAuthMode = (value: unknown): TAiDocAuthMode | undefined => {
+  return value === 'auto' || value === 'chatgpt' || value === 'apiKey' ? value : undefined;
+};
+
+const normalizeProvider = (value: unknown): plugins.smartai.TProvider | undefined => {
+  return ['anthropic', 'openai', 'google', 'groq', 'mistral', 'xai', 'perplexity', 'ollama'].includes(String(value))
+    ? value as plugins.smartai.TProvider
+    : undefined;
+};
+
+const normalizeChatGptSources = (value: unknown): plugins.smartaiOpenAiChatGptAuth.TOpenAiChatGptAuthSource[] | undefined => {
+  const input = typeof value === 'string' ? value.split(',').map(source => source.trim()) : value;
+  if (!Array.isArray(input)) return undefined;
+  const sources = input.filter((source): source is plugins.smartaiOpenAiChatGptAuth.TOpenAiChatGptAuthSource => {
+    return source === 'opencode' || source === 'codex' || source === 'smartai';
+  });
+  return sources.length > 0 ? sources : undefined;
+};
+
+const normalizeOpenAiReasoningEffort = (value: unknown): plugins.smartai.TOpenAiReasoningEffort | undefined => {
+  return ['none', 'minimal', 'low', 'medium', 'high', 'xhigh'].includes(String(value))
+    ? value as plugins.smartai.TOpenAiReasoningEffort
+    : undefined;
+};
+
+const getProjectTsdocConfig = async (projectDirArg: string): Promise<IAiDocConfig> => {
+  const smartconfigPath = plugins.path.join(projectDirArg, '.smartconfig.json');
+  if (!(await plugins.fsInstance.file(smartconfigPath).exists())) {
+    return {};
+  }
+  try {
+    const smartconfigJson = JSON.parse(String(await plugins.fsInstance.file(smartconfigPath).encoding('utf8').read()));
+    const legacyConfig = isPlainObject(smartconfigJson.tsdoc) ? smartconfigJson.tsdoc : {};
+    const namespacedConfig = isPlainObject(smartconfigJson['@git.zone/tsdoc']) ? smartconfigJson['@git.zone/tsdoc'] : {};
+    const config = {
+      ...legacyConfig,
+      ...namespacedConfig,
+      ...(isPlainObject(legacyConfig.ai) ? legacyConfig.ai : {}),
+      ...(isPlainObject(namespacedConfig.ai) ? namespacedConfig.ai : {}),
+    };
+    return config as IAiDocConfig;
+  } catch (error) {
+    throw new Error(`Could not parse .smartconfig.json: ${error instanceof Error ? error.message : String(error)}`);
+  }
+};
 
 export class AiDoc {
   private openaiToken = '';
@@ -9,6 +121,9 @@ export class AiDoc {
   public qenvInstance!: plugins.qenv.Qenv;
   public aidocInteract!: plugins.smartinteract.SmartInteract;
   public model!: plugins.smartai.LanguageModelV3;
+  public providerOptions?: plugins.smartai.TSmartAiProviderOptions;
+  public config: IAiDocResolvedConfig = defaultAiDocConfig;
+  public selectedAuthSource: string = 'none';
 
   argvArg: any;
 
@@ -16,83 +131,191 @@ export class AiDoc {
     this.argvArg = argvArg;
   }
 
-  private printSanitizedToken() {
-    // Check if the token length is greater than the sum of startLength and endLength
-    let printToken: string;
-    if (this.openaiToken.length > 6) {
-      // Extract the beginning and end parts of the token
-      const start = this.openaiToken.substring(0, 3);
-      const end = this.openaiToken.substring(this.openaiToken.length - 3);
-      printToken = `${start}...${end}`;
-    } else {
-      // If the token is not long enough, return it as is
-      printToken = this.openaiToken;
+  private get isInteractive(): boolean {
+    return process.stdin.isTTY === true && process.stdout.isTTY === true && !this.argvArg?.ci && !this.argvArg?.json;
+  }
+
+  private async migrateKeyValueStore(): Promise<void> {
+    const homeDir = plugins.smartpath.get.home();
+    const oldKvPath = plugins.path.join(homeDir, '.smartconfig/kv/tsdoc.json');
+    const newKvDir = plugins.path.join(homeDir, '.smartconfig/kv/@git.zone');
+    const newKvPath = plugins.path.join(newKvDir, 'tsdoc.json');
+    if (
+      await plugins.fsInstance.file(oldKvPath).exists() &&
+      !(await plugins.fsInstance.file(newKvPath).exists())
+    ) {
+      logger.log('info', 'Migrating tsdoc KeyValueStore to @git.zone/tsdoc...');
+      await plugins.fsInstance.directory(newKvDir).recursive().create();
+      await plugins.fsInstance.file(oldKvPath).copy(newKvPath);
+      await plugins.fsInstance.file(oldKvPath).delete();
+      logger.log('success', 'Migration complete: tsdoc.json -> @git.zone/tsdoc.json');
+    }
+  }
+
+  private async getStoredOpenAiToken(): Promise<string | undefined> {
+    if (!this.smartconfigKV) return undefined;
+    try {
+      const token = await this.smartconfigKV.readKey('OPENAI_TOKEN');
+      return token || undefined;
+    } catch {
+      return undefined;
+    }
+  }
+
+  private async resolveApiKey(provider: plugins.smartai.TProvider): Promise<string | undefined> {
+    const argvToken = this.argvArg?.OPENAI_TOKEN || this.argvArg?.OPENAI_API_KEY || this.argvArg?.apiKey;
+    if (argvToken) return argvToken;
+    if (this.config.apiKey) return this.config.apiKey;
+
+    const envNames = provider === 'openai'
+      ? ['OPENAI_TOKEN', 'OPENAI_API_KEY']
+      : [`${provider.toUpperCase()}_TOKEN`, `${provider.toUpperCase()}_API_KEY`];
+    for (const envName of envNames) {
+      const value = await this.qenvInstance.getEnvVarOnDemand(envName);
+      if (value) return value;
+    }
+
+    if (provider === 'openai') {
+      const storedToken = await this.getStoredOpenAiToken();
+      if (storedToken) return storedToken;
+    }
+
+    return undefined;
+  }
+
+  private async promptForOpenAiToken(): Promise<string> {
+    if (!this.isInteractive) {
+      throw new Error('OpenAI API key is required. Set OPENAI_TOKEN/OPENAI_API_KEY or configure ChatGPT subscription auth.');
     }
-    console.log(`OpenAI Token on record: ${printToken}`);
+    await plugins.smartdelay.delayFor(1000);
+    const answerObject = await this.aidocInteract.askQuestion({
+      type: 'input',
+      message: 'Please provide your OpenAI token. This will be persisted in your home directory.',
+      name: 'OPENAI_TOKEN',
+      default: '',
+    });
+    const token = answerObject.value;
+    await this.smartconfigKV?.writeKey('OPENAI_TOKEN', token);
+    return token;
+  }
+
+  private async runChatGptDeviceLogin(): Promise<plugins.smartai.IOpenAiChatGptTokenData> {
+    if (!this.isInteractive) {
+      throw new Error('ChatGPT subscription auth is required, but no usable auth file was found in non-interactive mode.');
+    }
+
+    const deviceCode = await plugins.smartai.requestOpenAiChatGptDeviceCode();
+    console.log(`Open ${deviceCode.verificationUrl} and enter code ${deviceCode.userCode}`);
+    const tokenData = await plugins.smartai.completeOpenAiChatGptDeviceCodeLogin(deviceCode);
+    const authFilePath = plugins.smartaiOpenAiChatGptAuth.getDefaultOpenAiChatGptAuthPath('smartai');
+    await plugins.smartaiOpenAiChatGptAuth.writeOpenAiChatGptAuthFile(authFilePath, tokenData, 'smartai');
+    return tokenData;
+  }
+
+  private async resolveConfig(): Promise<IAiDocResolvedConfig> {
+    const projectConfig = await getProjectTsdocConfig(process.cwd());
+    const envProvider = normalizeProvider(await this.qenvInstance.getEnvVarOnDemand('TSDOC_AI_PROVIDER'));
+    const envModel = await this.qenvInstance.getEnvVarOnDemand('TSDOC_AI_MODEL');
+    const envAuthMode = normalizeAuthMode(await this.qenvInstance.getEnvVarOnDemand('TSDOC_AUTH_MODE'));
+    const envChatGptSources = normalizeChatGptSources(await this.qenvInstance.getEnvVarOnDemand('TSDOC_CHATGPT_AUTH_SOURCES'));
+    const envReasoningEffort = normalizeOpenAiReasoningEffort(await this.qenvInstance.getEnvVarOnDemand('TSDOC_OPENAI_REASONING_EFFORT'));
+    const envProviderOptions = envReasoningEffort ? {
+      openai: {
+        reasoningEffort: envReasoningEffort,
+      },
+    } as plugins.smartai.TSmartAiProviderOptions : undefined;
+    const argvConfig: IAiDocConfig = {
+      provider: normalizeProvider(this.argvArg?.provider),
+      model: typeof this.argvArg?.model === 'string' ? this.argvArg.model : undefined,
+      authMode: normalizeAuthMode(this.argvArg?.authMode),
+      chatGptAuthSources: normalizeChatGptSources(this.argvArg?.chatGptAuthSources),
+    };
+    const provider = argvConfig.provider ?? envProvider ?? normalizeProvider(projectConfig.provider) ?? defaultAiDocConfig.provider;
+    const model = argvConfig.model ?? envModel ?? projectConfig.model ?? defaultAiDocConfig.model;
+    const authMode = argvConfig.authMode ?? envAuthMode ?? normalizeAuthMode(projectConfig.authMode) ?? defaultAiDocConfig.authMode;
+    const chatGptAuthSources = argvConfig.chatGptAuthSources
+      ?? envChatGptSources
+      ?? normalizeChatGptSources(projectConfig.chatGptAuthSources)
+      ?? defaultAiDocConfig.chatGptAuthSources;
+    const providerOptions = mergeProviderOptions(
+      mergeProviderOptions(defaultAiDocConfig.providerOptions, projectConfig.providerOptions),
+      envProviderOptions,
+    );
+
+    return {
+      ...defaultAiDocConfig,
+      ...projectConfig,
+      provider,
+      model,
+      authMode,
+      chatGptAuthSources,
+      chatGptAuthWriteBack: {
+        ...defaultAiDocConfig.chatGptAuthWriteBack,
+        ...(projectConfig.chatGptAuthWriteBack ?? {}),
+      },
+      providerOptions,
+      cache: projectConfig.cache ?? defaultAiDocConfig.cache,
+    };
   }
 
   public async start() {
-    // lets care about prerequisites
     this.aidocInteract = new plugins.smartinteract.SmartInteract();
     this.qenvInstance = new plugins.qenv.Qenv();
-    const openaiTokenFromEnv = await this.qenvInstance.getEnvVarOnDemand('OPENAI_TOKEN');
-    if (openaiTokenFromEnv) {
-      this.openaiToken = openaiTokenFromEnv;
-    } else {
-      // Migrate old KV store path to new path if needed
-      const homeDir = plugins.smartpath.get.home();
-      const oldKvPath = plugins.path.join(homeDir, '.smartconfig/kv/tsdoc.json');
-      const newKvDir = plugins.path.join(homeDir, '.smartconfig/kv/@git.zone');
-      const newKvPath = plugins.path.join(newKvDir, 'tsdoc.json');
-      if (
-        await plugins.fsInstance.file(oldKvPath).exists() &&
-        !(await plugins.fsInstance.file(newKvPath).exists())
-      ) {
-        console.log('Migrating tsdoc KeyValueStore to @git.zone/tsdoc...');
-        await plugins.fsInstance.directory(newKvDir).recursive().create();
-        await plugins.fsInstance.file(oldKvPath).copy(newKvPath);
-        await plugins.fsInstance.file(oldKvPath).delete();
-        console.log('Migration complete: tsdoc.json -> @git.zone/tsdoc.json');
-      }
+    await this.migrateKeyValueStore();
+    this.smartconfigKV = new plugins.smartconfig.KeyValueStore({
+      typeArg: 'userHomeDir',
+      identityArg: '@git.zone/tsdoc',
+      mandatoryKeys: ['OPENAI_TOKEN'],
+    });
+    this.config = await this.resolveConfig();
 
-      this.smartconfigKV = new plugins.smartconfig.KeyValueStore({
-        typeArg: 'userHomeDir',
-        identityArg: '@git.zone/tsdoc',
-        mandatoryKeys: ['OPENAI_TOKEN'],
+    let openAiChatGptAuth: plugins.smartai.IOpenAiChatGptTokenData | undefined;
+    if (this.config.provider === 'openai' && this.config.authMode !== 'apiKey') {
+      const resolvedAuth = await plugins.smartaiOpenAiChatGptAuth.resolveOpenAiChatGptAuth({
+        sources: this.config.chatGptAuthSources,
+        refresh: 'ifNeeded',
+        writeBack: this.config.chatGptAuthWriteBack,
       });
+      if (resolvedAuth) {
+        openAiChatGptAuth = resolvedAuth.tokenData;
+        this.selectedAuthSource = resolvedAuth.source;
+        logger.log('info', `Using OpenAI ChatGPT auth from ${resolvedAuth.source}.`);
+      } else if (this.config.authMode === 'chatgpt') {
+        openAiChatGptAuth = await this.runChatGptDeviceLogin();
+        this.selectedAuthSource = 'smartai';
+      }
+    }
 
-      const missingKeys = await this.smartconfigKV.getMissingMandatoryKeys();
-      if (missingKeys.length > 0) {
-        // lets try argv
-        if (this.argvArg?.OPENAI_TOKEN) {
-          this.openaiToken = this.argvArg.OPENAI_TOKEN;
-        } else {
-          // lets try smartinteract
-          // wait for a second until OpenAI fixes punycode problem...
-          await plugins.smartdelay.delayFor(1000);
-          const answerObject = await this.aidocInteract.askQuestion({
-            type: 'input',
-            message: `Please provide your OpenAI token. This will be persisted in your home directory.`,
-            name: 'OPENAI_TOKEN',
-            default: '',
-          });
-          this.openaiToken = answerObject.value;
+    let apiKey: string | undefined;
+    if (!openAiChatGptAuth) {
+      apiKey = await this.resolveApiKey(this.config.provider);
+      if (!apiKey && this.config.provider === 'openai' && this.config.authMode === 'auto' && this.isInteractive) {
+        openAiChatGptAuth = await this.runChatGptDeviceLogin();
+        this.selectedAuthSource = 'smartai';
+      }
+      if (!apiKey && !openAiChatGptAuth && this.config.provider === 'openai' && this.config.authMode !== 'chatgpt') {
+        apiKey = await this.promptForOpenAiToken();
+      }
+      if (apiKey) {
+        this.selectedAuthSource = 'apiKey';
+        if (this.config.provider === 'openai') {
+          this.openaiToken = apiKey;
         }
-
-        this.printSanitizedToken();
-        await this.smartconfigKV.writeKey('OPENAI_TOKEN', this.openaiToken);
       }
     }
-    if (!this.openaiToken && this.smartconfigKV) {
-      this.openaiToken = await this.smartconfigKV.readKey('OPENAI_TOKEN');
-    }
 
-    // Create model using getModel()
-    this.model = plugins.smartai.getModel({
-      provider: 'openai',
-      model: 'gpt-5.4',
-      apiKey: this.openaiToken,
+    const setup = plugins.smartai.getModelSetup({
+      provider: this.config.provider,
+      model: this.config.model,
+      apiKey,
+      openAiChatGptAuth,
+      providerOptions: this.config.providerOptions,
+      promptCaching: this.config.promptCaching,
+      baseUrl: this.config.baseUrl,
+      ollamaOptions: this.config.ollamaOptions,
     });
+    this.model = setup.model;
+    this.providerOptions = setup.providerOptions;
   }
 
   public async stop() {
@@ -103,6 +326,35 @@ export class AiDoc {
     return this.openaiToken;
   }
 
+  public async runAgent(options: Omit<plugins.smartagent.IAgentRunOptions, 'model'> & {
+    projectDir: string;
+    taskName: string;
+    useCompaction?: boolean;
+  }): Promise<plugins.smartagent.IAgentRunResult> {
+    const providerOptions = this.config.provider === 'openai' && this.selectedAuthSource !== 'apiKey' && options.system
+      ? mergeProviderOptions(this.providerOptions, {
+          openai: {
+            instructions: options.system,
+          },
+        })
+      : this.providerOptions;
+    const result = await plugins.smartagent.runAgent({
+      ...options,
+      model: this.model,
+      providerOptions,
+      cache: this.config.cache,
+      sessionId: options.sessionId ?? `tsdoc:${options.taskName}:${plugins.path.resolve(options.projectDir)}`,
+      onContextOverflow: options.useCompaction
+        ? async (messages) => plugins.smartagentCompaction.compactMessages(this.model, messages)
+        : options.onContextOverflow,
+    });
+    logger.log(
+      'info',
+      `[${options.taskName}] tokens input=${result.usage.inputTokens} output=${result.usage.outputTokens} total=${result.usage.totalTokens} cacheRead=${result.usage.cacheReadTokens} cacheWrite=${result.usage.cacheWriteTokens}`,
+    );
+    return result;
+  }
+
   public async buildReadme(projectDirArg: string) {
     const readmeInstance = new aiDocsClasses.Readme(this, projectDirArg);
     return await readmeInstance.build();

package/ts/classes.diffprocessor.ts

@@ -160,24 +160,18 @@ export class DiffProcessor {
 
     const lines = diffString.split('\n');
     let filepath = '';
+    let oldPath = '';
+    let newPath = '';
     let status: 'added' | 'modified' | 'deleted' = 'modified';
     let linesAdded = 0;
     let linesRemoved = 0;
 
     // Parse diff header to extract filepath and status
     for (const line of lines) {
-      if (line.startsWith('--- a/')) {
-        filepath = line.substring(6);
-      } else if (line.startsWith('+++ b/')) {
-        const newPath = line.substring(6);
-        if (newPath === '/dev/null') {
-          status = 'deleted';
-        } else if (filepath === '/dev/null') {
-          status = 'added';
-          filepath = newPath;
-        } else {
-          filepath = newPath;
-        }
+      if (line.startsWith('--- ')) {
+        oldPath = this.normalizeDiffPath(line.substring(4));
+      } else if (line.startsWith('+++ ')) {
+        newPath = this.normalizeDiffPath(line.substring(4));
       } else if (line.startsWith('+') && !line.startsWith('+++')) {
         linesAdded++;
       } else if (line.startsWith('-') && !line.startsWith('---')) {
@@ -185,6 +179,16 @@ export class DiffProcessor {
       }
     }
 
+    if (oldPath === '/dev/null') {
+      status = 'added';
+      filepath = newPath;
+    } else if (newPath === '/dev/null') {
+      status = 'deleted';
+      filepath = oldPath;
+    } else {
+      filepath = newPath || oldPath;
+    }
+
     const totalLines = linesAdded + linesRemoved;
     const estimatedTokens = Math.ceil(diffString.length / 4);
 
@@ -199,6 +203,12 @@ export class DiffProcessor {
     };
   }
 
+  private normalizeDiffPath(pathArg: string): string {
+    const cleanPath = pathArg.trim().split('\t')[0].split(' ')[0];
+    if (cleanPath === '/dev/null') return cleanPath;
+    return cleanPath.replace(/^a\//, '').replace(/^b\//, '');
+  }
+
   /**
    * Prioritize files by importance (source files before build artifacts)
    */
@@ -215,7 +225,7 @@ export class DiffProcessor {
    */
   private getFileImportanceScore(filepath: string): number {
     // Source files - highest priority
-    if (filepath.match(/^(src|lib|app|components|pages|api)\//)) {
+    if (filepath.match(/^(ts|ts_web|src|lib|app|components|pages|api)\//)) {
       return 100;
     }