@git.zone/tsdoc 2.0.6 → 2.1.0

package/ts/classes.aidoc.ts

@@ -3,70 +3,18 @@ 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 type TAiDocAuthMode = plugins.tsagent.TTsAgentAuthMode;
 
-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 IAiDocConfig extends plugins.tsagent.ITsAgentConfig {}
 
-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 interface IAiDocResolvedConfig extends plugins.tsagent.ITsAgentResolvedConfig {}
 
 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',
+  ...plugins.tsagent.defaultTsAgentConfig,
 };
 
-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;
-};
+type TAiDocRunAgentOptions = Parameters<plugins.tsagent.TsAgent['runAgent']>[0];
+type TAiDocRunAgentResult = Awaited<ReturnType<plugins.tsagent.TsAgent['runAgent']>>;
 
 const normalizeAuthMode = (value: unknown): TAiDocAuthMode | undefined => {
   return value === 'auto' || value === 'chatgpt' || value === 'apiKey' ? value : undefined;
@@ -93,46 +41,29 @@ const normalizeOpenAiReasoningEffort = (value: unknown): plugins.smartai.TOpenAi
     : 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 tsAgent?: plugins.tsagent.TsAgent;
   private openaiToken = '';
 
   public smartconfigKV?: plugins.smartconfig.KeyValueStore<{ OPENAI_TOKEN: string }>;
-  public qenvInstance!: plugins.qenv.Qenv;
-  public aidocInteract!: plugins.smartinteract.SmartInteract;
-  public model!: plugins.smartai.LanguageModelV3;
-  public providerOptions?: plugins.smartai.TSmartAiProviderOptions;
+  public qenvInstance?: plugins.qenv.Qenv;
+  public aidocInteract?: plugins.smartinteract.SmartInteract;
+  public model!: plugins.tsagent.TsAgent['model'];
+  public providerOptions?: IAiDocResolvedConfig['providerOptions'];
   public config: IAiDocResolvedConfig = defaultAiDocConfig;
   public selectedAuthSource: string = 'none';
 
-  argvArg: any;
+  public argvArg: any;
 
   constructor(argvArg?: any) {
-    this.argvArg = argvArg;
+    this.argvArg = argvArg || {};
   }
 
-  private get isInteractive(): boolean {
-    return process.stdin.isTTY === true && process.stdout.isTTY === true && !this.argvArg?.ci && !this.argvArg?.json;
+  private get activeTsAgent(): plugins.tsagent.TsAgent {
+    if (!this.tsAgent) {
+      throw new Error('AiDoc.start() must be called before running AI tasks.');
+    }
+    return this.tsAgent;
   }
 
   private async migrateKeyValueStore(): Promise<void> {
@@ -152,201 +83,65 @@ export class AiDoc {
     }
   }
 
-  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.');
-    }
-    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());
+  private async resolveTsdocEnvConfig(): Promise<IAiDocConfig> {
+    this.qenvInstance = new plugins.qenv.Qenv();
     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,
+      provider: envProvider,
+      model: envModel || undefined,
+      authMode: envAuthMode,
+      chatGptAuthSources: envChatGptSources,
+      providerOptions: envReasoningEffort ? {
+        openai: {
+          reasoningEffort: envReasoningEffort,
+        },
+      } : undefined,
     };
   }
 
   public async start() {
-    this.aidocInteract = new plugins.smartinteract.SmartInteract();
-    this.qenvInstance = new plugins.qenv.Qenv();
     await this.migrateKeyValueStore();
     this.smartconfigKV = new plugins.smartconfig.KeyValueStore({
       typeArg: 'userHomeDir',
       identityArg: '@git.zone/tsdoc',
       mandatoryKeys: ['OPENAI_TOKEN'],
     });
-    this.config = await this.resolveConfig();
 
-    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';
-      }
-    }
-
-    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;
-        }
-      }
-    }
-
-    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.tsAgent = new plugins.tsagent.TsAgent({
+      argvArg: this.argvArg,
+      projectDir: process.cwd(),
+      projectConfigKeys: ['@git.zone/tsagent', 'tsdoc', '@git.zone/tsdoc'],
+      legacyTokenStoreIdentities: ['@git.zone/tsdoc'],
+      config: await this.resolveTsdocEnvConfig(),
     });
-    this.model = setup.model;
-    this.providerOptions = setup.providerOptions;
+    await this.tsAgent.start();
+
+    this.model = this.tsAgent.model;
+    this.providerOptions = this.tsAgent.providerOptions;
+    this.config = this.tsAgent.config as IAiDocResolvedConfig;
+    this.selectedAuthSource = this.tsAgent.selectedAuthSource;
+    this.openaiToken = this.tsAgent.getOpenaiToken();
+    if (this.selectedAuthSource !== 'none') {
+      logger.log('info', `Using AI auth from ${this.selectedAuthSource}.`);
+    }
   }
 
   public async stop() {
-    // No lifecycle management needed with getModel() API
+    await this.tsAgent?.stop();
   }
 
   public getOpenaiToken(): string {
     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({
+  public async runAgent(options: TAiDocRunAgentOptions): Promise<TAiDocRunAgentResult> {
+    const result = await this.activeTsAgent.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',

package/ts/cli.ts

@@ -6,12 +6,6 @@ import { TypeDoc } from './classes.typedoc.js';
 import { AiDoc } from './classes.aidoc.js';
 import { NoChangesError } from './aidocs_classes/commit.js';
 
-const defaultChatGptAuthSources: plugins.smartaiOpenAiChatGptAuth.TOpenAiChatGptAuthSource[] = [
-  'opencode',
-  'codex',
-  'smartai',
-];
-
 const createAiDoc = async (argvArg: any): Promise<AiDoc> => {
   const aidocInstance = new AiDoc(argvArg);
   await aidocInstance.start();
@@ -27,18 +21,11 @@ const getSmartcliArgv = (): string[] | undefined => {
 const handleAuthCommand = async (argvArg: any): Promise<void> => {
   const subcommand = argvArg._?.[1] ?? 'status';
   if (subcommand === 'login') {
-    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');
-    logger.log('success', `Stored OpenAI ChatGPT auth at ${authFilePath}`);
+    await plugins.tsagent.loginChatGptAuth();
     return;
   }
 
-  const inspections = await plugins.smartaiOpenAiChatGptAuth.inspectOpenAiChatGptAuthSources({
-    sources: defaultChatGptAuthSources,
-  });
+  const inspections = await plugins.tsagent.inspectChatGptAuthSources();
   console.log('OpenAI ChatGPT auth sources:');
   for (const inspection of inspections) {
     const status = inspection.usable

package/ts/helpers.agenttools.ts

@@ -1,125 +1,5 @@
 import * as plugins from './plugins.js';
 
-const defaultDeniedSegments = new Set([
-  '.cache',
-  '.git',
-  '.next',
-  '.nogit',
-  '.rpt2_cache',
-  'build',
-  'coverage',
-  'dist',
-  'node_modules',
-  'out',
-]);
-
-const defaultDeniedBasenames = new Set([
-  '.npmrc',
-  'bun.lockb',
-  'credentials.json',
-  'deno.lock',
-  'npm-shrinkwrap.json',
-  'package-lock.json',
-  'pnpm-lock.yaml',
-  'yarn.lock',
-]);
-
-const normalizeRelativePath = (rootDir: string, inputPath: string): string => {
-  const resolvedRoot = plugins.path.resolve(rootDir);
-  const resolvedPath = plugins.path.resolve(
-    plugins.path.isAbsolute(inputPath) ? inputPath : plugins.path.join(resolvedRoot, inputPath),
-  );
-  if (resolvedPath !== resolvedRoot && !resolvedPath.startsWith(`${resolvedRoot}${plugins.path.sep}`)) {
-    throw new Error(`Access denied: "${inputPath}" is outside allowed root "${rootDir}"`);
-  }
-
-  const relativePath = plugins.path.relative(resolvedRoot, resolvedPath) || '.';
-  assertAllowedRelativePath(relativePath);
-  return resolvedPath;
-};
-
-const assertAllowedRelativePath = (relativePath: string): void => {
-  const normalized = relativePath.split(plugins.path.sep).join('/');
-  const parts = normalized.split('/').filter(Boolean);
-  const basename = parts.at(-1) ?? normalized;
-
-  if (basename === '.env' || basename.startsWith('.env.')) {
-    throw new Error(`Access denied: ${relativePath} may contain environment secrets.`);
-  }
-  if (basename.endsWith('.pem') || basename.endsWith('.key') || basename.endsWith('.p12')) {
-    throw new Error(`Access denied: ${relativePath} may contain private key material.`);
-  }
-  if (defaultDeniedBasenames.has(basename)) {
-    throw new Error(`Access denied: ${relativePath} is excluded from AI file access.`);
-  }
-  for (const segment of parts) {
-    if (defaultDeniedSegments.has(segment) || segment.startsWith('dist_')) {
-      throw new Error(`Access denied: ${relativePath} is excluded from AI file access.`);
-    }
-  }
-};
-
-const listDirectory = async (dirPath: string, recursive = false, prefix = ''): Promise<string[]> => {
-  const entries = await plugins.fs.readdir(dirPath, { withFileTypes: true });
-  const result: string[] = [];
-  for (const entry of entries) {
-    const relativeEntryPath = prefix ? `${prefix}/${entry.name}` : entry.name;
-    try {
-      assertAllowedRelativePath(relativeEntryPath);
-    } catch {
-      continue;
-    }
-    result.push(`${relativeEntryPath}${entry.isDirectory() ? '/' : ''}`);
-    if (recursive && entry.isDirectory()) {
-      result.push(...await listDirectory(plugins.path.join(dirPath, entry.name), true, relativeEntryPath));
-    }
-  }
-  return result;
-};
-
-export const createReadOnlyFileSystemTools = (rootDirArg: string): plugins.smartai.ToolSet => {
-  const rootDir = plugins.path.resolve(rootDirArg);
-
-  return {
-    read_file: plugins.smartagent.tool({
-      description: 'Read file contents within the project. Secret and generated paths are blocked.',
-      inputSchema: plugins.smartagent.z.object({
-        path: plugins.smartagent.z.string().describe('Absolute or project-relative path to the file'),
-        startLine: plugins.smartagent.z.number().optional().describe('First line, 1-indexed and inclusive'),
-        endLine: plugins.smartagent.z.number().optional().describe('Last line, 1-indexed and inclusive'),
-      }),
-      execute: async ({ path: filePath, startLine, endLine }: {
-        path: string;
-        startLine?: number;
-        endLine?: number;
-      }) => {
-        const resolvedPath = normalizeRelativePath(rootDir, filePath);
-        const stat = await plugins.fs.stat(resolvedPath);
-        if (!stat.isFile()) {
-          throw new Error(`Cannot read non-file path: ${filePath}`);
-        }
-        const content = await plugins.fs.readFile(resolvedPath, 'utf8');
-        const selectedContent = startLine !== undefined || endLine !== undefined
-          ? content.split('\n').slice((startLine ?? 1) - 1, endLine).join('\n')
-          : content;
-        return plugins.smartagent.truncateOutput(selectedContent).content;
-      },
-    }),
-    list_directory: plugins.smartagent.tool({
-      description: 'List project files and directories. Secret and generated paths are omitted.',
-      inputSchema: plugins.smartagent.z.object({
-        path: plugins.smartagent.z.string().describe('Absolute or project-relative directory path to list'),
-        recursive: plugins.smartagent.z.boolean().optional().describe('List recursively'),
-      }),
-      execute: async ({ path: dirPath, recursive }: { path: string; recursive?: boolean }) => {
-        const resolvedPath = normalizeRelativePath(rootDir, dirPath);
-        const stat = await plugins.fs.stat(resolvedPath);
-        if (!stat.isDirectory()) {
-          throw new Error(`Cannot list non-directory path: ${dirPath}`);
-        }
-        const entries = await listDirectory(resolvedPath, recursive === true);
-        return plugins.smartagent.truncateOutput(entries.join('\n')).content;
-      },
-    }),
-  };
+export const createReadOnlyFileSystemTools = async (rootDirArg: string) => {
+  return await plugins.tsagent.createReadOnlyProjectTools(rootDirArg);
 };

package/ts/plugins.ts

@@ -53,9 +53,10 @@ export const fsInstance = new smartfs.SmartFs(smartFsNodeProvider);
 export const smartfileFactory = smartfile.SmartFileFactory.nodeFs();
 
 // @git.zone scope
+import * as tsagent from '@git.zone/tsagent';
 import * as tspublish from '@git.zone/tspublish';
 
-export { tspublish };
+export { tsagent, tspublish };
 
 // third party scope
 import * as typedoc from 'typedoc';