@git.zone/tsagent 1.1.0

package/ts/classes.tsagent.ts

@@ -0,0 +1,424 @@
+import * as plugins from './plugins.js';
+import { createReadOnlyProjectTools } from './tools.project.js';
+
+export type TTsAgentAuthMode = 'auto' | 'chatgpt' | 'apiKey';
+
+export interface ITsAgentConfig {
+  provider?: plugins.smartai.TProvider;
+  model?: string;
+  authMode?: TTsAgentAuthMode;
+  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 ITsAgentResolvedConfig extends Required<Pick<ITsAgentConfig,
+  '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 ITsAgentOptions {
+  argvArg?: any;
+  projectDir?: string;
+  projectConfigKeys?: string[];
+  legacyTokenStoreIdentities?: string[];
+  config?: ITsAgentConfig;
+}
+
+export interface IRunJsonTaskOptions<T> {
+  taskName: string;
+  projectDir: string;
+  prompt: string;
+  system?: string;
+  tools?: plugins.smartai.ToolSet;
+  maxSteps?: number;
+  useCompaction?: boolean;
+  validate?: (value: T) => string | void;
+}
+
+export const defaultTsAgentConfig: ITsAgentResolvedConfig = {
+  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',
+};
+
+export const defaultChatGptAuthSources = defaultTsAgentConfig.chatGptAuthSources;
+
+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): TTsAgentAuthMode | 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 readProjectConfig = async (projectDirArg: string, keysArg: string[]): Promise<ITsAgentConfig> => {
+  const smartconfigPath = plugins.path.join(projectDirArg, '.smartconfig.json');
+  try {
+    const raw = await plugins.fs.readFile(smartconfigPath, 'utf8');
+    const smartconfigJson = JSON.parse(raw);
+    const result: Record<string, any> = {};
+    for (const key of keysArg) {
+      const keyConfig = isPlainObject(smartconfigJson[key]) ? smartconfigJson[key] : {};
+      Object.assign(result, keyConfig);
+      if (isPlainObject(keyConfig.ai)) {
+        Object.assign(result, keyConfig.ai);
+      }
+    }
+    return result as ITsAgentConfig;
+  } catch (error) {
+    if ((error as { code?: string }).code === 'ENOENT') {
+      return {};
+    }
+    throw new Error(`Could not parse .smartconfig.json: ${error instanceof Error ? error.message : String(error)}`);
+  }
+};
+
+const parseJsonResult = <T>(textArg: string): T => {
+  const jsonString = textArg
+    .replace(/```json\n?/gi, '')
+    .replace(/```\n?/gi, '')
+    .match(/\{[\s\S]*\}|\[[\s\S]*\]/)?.[0] ?? textArg;
+  return JSON.parse(jsonString) as T;
+};
+
+export class TsAgent {
+  private readonly argvArg: any;
+  private readonly projectDir: string;
+  private readonly projectConfigKeys: string[];
+  private readonly legacyTokenStoreIdentities: string[];
+  private readonly configOverride?: ITsAgentConfig;
+  private openaiToken = '';
+  private tokenStore?: plugins.smartconfig.KeyValueStore<{ OPENAI_TOKEN: string }>;
+  private legacyTokenStores: Array<plugins.smartconfig.KeyValueStore<{ OPENAI_TOKEN: string }>> = [];
+  private qenvInstance!: plugins.qenv.Qenv;
+  private interact!: plugins.smartinteract.SmartInteract;
+
+  public model!: plugins.smartai.LanguageModelV3;
+  public providerOptions?: plugins.smartai.TSmartAiProviderOptions;
+  public config: ITsAgentResolvedConfig = defaultTsAgentConfig;
+  public selectedAuthSource = 'none';
+
+  constructor(optionsArg: ITsAgentOptions = {}) {
+    this.argvArg = optionsArg.argvArg || {};
+    this.projectDir = optionsArg.projectDir || process.cwd();
+    this.projectConfigKeys = optionsArg.projectConfigKeys || ['@git.zone/tsagent'];
+    this.legacyTokenStoreIdentities = optionsArg.legacyTokenStoreIdentities || [];
+    this.configOverride = optionsArg.config;
+  }
+
+  private get isInteractive(): boolean {
+    return process.stdin.isTTY === true && process.stdout.isTTY === true && !this.argvArg?.ci && !this.argvArg?.json;
+  }
+
+  private async readTokenFromStore(storeArg: plugins.smartconfig.KeyValueStore<{ OPENAI_TOKEN: string }>): Promise<string | undefined> {
+    try {
+      const token = await storeArg.readKey('OPENAI_TOKEN');
+      return token || undefined;
+    } catch {
+      return undefined;
+    }
+  }
+
+  private async getStoredOpenAiToken(): Promise<string | undefined> {
+    if (this.tokenStore) {
+      const token = await this.readTokenFromStore(this.tokenStore);
+      if (token) return token;
+    }
+    for (const store of this.legacyTokenStores) {
+      const token = await this.readTokenFromStore(store);
+      if (token) return token;
+    }
+    return undefined;
+  }
+
+  private async resolveApiKey(providerArg: 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 = providerArg === 'openai'
+      ? ['OPENAI_TOKEN', 'OPENAI_API_KEY']
+      : [`${providerArg.toUpperCase()}_TOKEN`, `${providerArg.toUpperCase()}_API_KEY`];
+    for (const envName of envNames) {
+      const value = await this.qenvInstance.getEnvVarOnDemand(envName);
+      if (value) return value;
+    }
+
+    if (providerArg === 'openai') {
+      return await this.getStoredOpenAiToken();
+    }
+    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.interact.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.tokenStore?.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.');
+    }
+    return await loginChatGptAuth();
+  }
+
+  private async resolveConfig(): Promise<ITsAgentResolvedConfig> {
+    const projectConfig = await readProjectConfig(this.projectDir, this.projectConfigKeys);
+    const envProvider = normalizeProvider(await this.qenvInstance.getEnvVarOnDemand('TSAGENT_AI_PROVIDER'));
+    const envModel = await this.qenvInstance.getEnvVarOnDemand('TSAGENT_AI_MODEL');
+    const envAuthMode = normalizeAuthMode(await this.qenvInstance.getEnvVarOnDemand('TSAGENT_AUTH_MODE'));
+    const envChatGptSources = normalizeChatGptSources(await this.qenvInstance.getEnvVarOnDemand('TSAGENT_CHATGPT_AUTH_SOURCES'));
+    const envReasoningEffort = normalizeOpenAiReasoningEffort(await this.qenvInstance.getEnvVarOnDemand('TSAGENT_OPENAI_REASONING_EFFORT'));
+    const envProviderOptions = envReasoningEffort ? {
+      openai: { reasoningEffort: envReasoningEffort },
+    } as plugins.smartai.TSmartAiProviderOptions : undefined;
+    const argvConfig: ITsAgentConfig = {
+      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 mergedConfig: ITsAgentConfig = {
+      ...projectConfig,
+      ...this.configOverride,
+      ...argvConfig,
+    };
+    const provider = argvConfig.provider ?? envProvider ?? normalizeProvider(mergedConfig.provider) ?? defaultTsAgentConfig.provider;
+    const model = argvConfig.model ?? envModel ?? mergedConfig.model ?? defaultTsAgentConfig.model;
+    const authMode = argvConfig.authMode ?? envAuthMode ?? normalizeAuthMode(mergedConfig.authMode) ?? defaultTsAgentConfig.authMode;
+    const chatGptAuthSources = argvConfig.chatGptAuthSources
+      ?? envChatGptSources
+      ?? normalizeChatGptSources(mergedConfig.chatGptAuthSources)
+      ?? defaultTsAgentConfig.chatGptAuthSources;
+    const providerOptions = mergeProviderOptions(
+      mergeProviderOptions(defaultTsAgentConfig.providerOptions, mergedConfig.providerOptions),
+      envProviderOptions,
+    );
+    return {
+      ...defaultTsAgentConfig,
+      ...mergedConfig,
+      provider,
+      model,
+      authMode,
+      chatGptAuthSources,
+      chatGptAuthWriteBack: {
+        ...defaultTsAgentConfig.chatGptAuthWriteBack,
+        ...(mergedConfig.chatGptAuthWriteBack ?? {}),
+      },
+      providerOptions,
+      cache: mergedConfig.cache ?? defaultTsAgentConfig.cache,
+    };
+  }
+
+  public async start(): Promise<void> {
+    this.interact = new plugins.smartinteract.SmartInteract();
+    this.qenvInstance = new plugins.qenv.Qenv();
+    this.tokenStore = new plugins.smartconfig.KeyValueStore({
+      typeArg: 'userHomeDir',
+      identityArg: '@git.zone/tsagent',
+      mandatoryKeys: ['OPENAI_TOKEN'],
+    });
+    this.legacyTokenStores = this.legacyTokenStoreIdentities.map(identityArg => new plugins.smartconfig.KeyValueStore({
+      typeArg: 'userHomeDir',
+      identityArg,
+      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;
+      } 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.model = setup.model;
+    this.providerOptions = setup.providerOptions;
+  }
+
+  public async stop(): Promise<void> {}
+
+  public getOpenaiToken(): string {
+    return this.openaiToken;
+  }
+
+  public async createReadOnlyProjectTools(projectDirArg = this.projectDir): Promise<plugins.smartai.ToolSet> {
+    return await createReadOnlyProjectTools(projectDirArg);
+  }
+
+  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 ?? `tsagent:${options.taskName}:${plugins.path.resolve(options.projectDir)}`,
+      onContextOverflow: options.useCompaction
+        ? async (messages) => plugins.smartagentCompaction.compactMessages(this.model, messages)
+        : options.onContextOverflow,
+    });
+    return result;
+  }
+
+  public async runJsonTask<T = unknown>(optionsArg: IRunJsonTaskOptions<T>): Promise<T> {
+    const tools = optionsArg.tools || await this.createReadOnlyProjectTools(optionsArg.projectDir);
+    const result = await this.runAgent({
+      taskName: optionsArg.taskName,
+      projectDir: optionsArg.projectDir,
+      prompt: optionsArg.prompt,
+      system: `${optionsArg.system || 'Return only valid JSON.'}\nYour final response must be parseable JSON with no markdown wrapper.`,
+      tools,
+      maxSteps: optionsArg.maxSteps ?? 15,
+      maxValidationRetries: 1,
+      useCompaction: optionsArg.useCompaction ?? true,
+      validateCompletion: (resultArg) => {
+        try {
+          const parsed = parseJsonResult<T>(resultArg.text);
+          return optionsArg.validate?.(parsed);
+        } catch (error) {
+          return `Return only valid JSON. Error: ${error instanceof Error ? error.message : String(error)}`;
+        }
+      },
+    });
+    const parsed = parseJsonResult<T>(result.text);
+    const validation = optionsArg.validate?.(parsed);
+    if (validation) {
+      throw new Error(validation);
+    }
+    return parsed;
+  }
+}
+
+export const inspectChatGptAuthSources = async (sourcesArg = defaultChatGptAuthSources) => {
+  return await plugins.smartaiOpenAiChatGptAuth.inspectOpenAiChatGptAuthSources({
+    sources: sourcesArg,
+  });
+};
+
+export const loginChatGptAuth = async (): Promise<plugins.smartai.IOpenAiChatGptTokenData> => {
+  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');
+  console.log(`Stored OpenAI ChatGPT auth at ${authFilePath}`);
+  return tokenData;
+};

package/ts/cli.ts

@@ -0,0 +1,133 @@
+import * as plugins from './plugins.js';
+import * as paths from './paths.js';
+import { TsAgent, inspectChatGptAuthSources, loginChatGptAuth, type ITsAgentResolvedConfig } from './classes.tsagent.js';
+
+const sensitiveConfigKeyRegex = /(^apiKey$|api[_-]?key|token|secret|password|credential|authorization)/i;
+
+const redactSensitiveConfigValues = (valueArg: unknown, keyArg?: string): unknown => {
+  if (keyArg && sensitiveConfigKeyRegex.test(keyArg)) {
+    return valueArg ? '[redacted]' : valueArg;
+  }
+  if (Array.isArray(valueArg)) {
+    return valueArg.map(value => redactSensitiveConfigValues(value));
+  }
+  if (typeof valueArg === 'object' && valueArg !== null) {
+    return Object.fromEntries(Object.entries(valueArg).map(([key, value]) => [
+      key,
+      redactSensitiveConfigValues(value, key),
+    ]));
+  }
+  return valueArg;
+};
+
+export const redactConfigForOutput = (configArg: ITsAgentResolvedConfig): ITsAgentResolvedConfig => {
+  return redactSensitiveConfigValues(configArg) as ITsAgentResolvedConfig;
+};
+
+const getPrompt = async (argvArg: any): Promise<string> => {
+  const positional = (argvArg._ || []).slice(1).join(' ').trim();
+  if (positional) return positional;
+  if (typeof argvArg.prompt === 'string') return argvArg.prompt;
+  const interact = new plugins.smartinteract.SmartInteract();
+  const answer = await interact.askQuestion({
+    type: 'input',
+    name: 'prompt',
+    message: 'What should tsagent help with?',
+    default: '',
+  });
+  return answer.value;
+};
+
+const runChat = async (argvArg: any): Promise<void> => {
+  const prompt = await getPrompt(argvArg);
+  const agent = new TsAgent({ argvArg, projectDir: paths.cwd });
+  await agent.start();
+  try {
+    const tools = argvArg.repo ? await agent.createReadOnlyProjectTools(paths.cwd) : undefined;
+    const result = await agent.runAgent({
+      taskName: 'chat',
+      projectDir: paths.cwd,
+      system: argvArg.repo
+        ? 'You are a concise repo-aware engineering assistant. You can read files but must not reveal secrets.'
+        : 'You are a concise engineering assistant.',
+      prompt,
+      tools,
+      maxSteps: argvArg.repo ? 20 : 3,
+      useCompaction: true,
+      onToolCall: (toolName) => console.log(`[tool] ${toolName}`),
+    });
+    console.log(result.text);
+  } finally {
+    await agent.stop();
+  }
+};
+
+const runAuth = async (argvArg: any): Promise<void> => {
+  const subcommand = argvArg._?.[1] || 'status';
+  if (subcommand === 'login') {
+    await loginChatGptAuth();
+    return;
+  }
+  const inspections = await inspectChatGptAuthSources();
+  console.log('OpenAI ChatGPT auth sources:');
+  for (const inspection of inspections) {
+    const status = inspection.usable
+      ? 'usable'
+      : inspection.exists
+        ? inspection.expired
+          ? 'expired'
+          : 'not usable'
+        : 'missing';
+    const account = inspection.email ? ` (${inspection.email})` : '';
+    console.log(`  ${inspection.source}: ${status}${account} - ${inspection.filePath}`);
+  }
+};
+
+const runConfig = async (argvArg: any): Promise<void> => {
+  const subcommand = argvArg._?.[1] || 'show';
+  if (subcommand !== 'show') {
+    throw new Error(`Unknown config subcommand: ${subcommand}`);
+  }
+  const agent = new TsAgent({ argvArg, projectDir: paths.cwd });
+  await agent.start();
+  try {
+    console.log(JSON.stringify({
+      config: redactConfigForOutput(agent.config),
+      selectedAuthSource: agent.selectedAuthSource,
+    }, null, 2));
+  } finally {
+    await agent.stop();
+  }
+};
+
+const printHelp = () => {
+  console.log(`
+Usage: tsagent <command> [options]
+
+Commands:
+  chat [--repo] [prompt]      Chat directly with the configured model
+  auth [status|login]         Inspect or create ChatGPT subscription auth
+  config show                 Show resolved tsagent config
+
+Examples:
+  tsagent chat "explain this project"
+  tsagent chat --repo "which file exports the public API?"
+  tsagent auth status
+`);
+};
+
+export const runCli = async () => {
+  const cli = new plugins.smartcli.Smartcli();
+  cli.standardCommand().subscribe(async (argvArg) => {
+    if (argvArg.help || argvArg.h) {
+      printHelp();
+      return;
+    }
+    await runChat(argvArg);
+  });
+  cli.addCommand('chat').subscribe(runChat);
+  cli.addCommand('auth').subscribe(runAuth);
+  cli.addCommand('config').subscribe(runConfig);
+  cli.addCommand('help').subscribe(async () => printHelp());
+  cli.startParse();
+};

package/ts/index.ts

@@ -0,0 +1,3 @@
+export * from './classes.tsagent.js';
+export * from './tools.project.js';
+export * from './cli.js';

package/ts/paths.ts

@@ -0,0 +1,4 @@
+import * as plugins from './plugins.js';
+
+export const cwd = process.cwd();
+export const packageBase = plugins.path.resolve(new URL('..', import.meta.url).pathname);

package/ts/plugins.ts

@@ -0,0 +1,30 @@
+// node native scope
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+
+export { fs, path };
+
+// @push.rocks scope
+import * as qenv from '@push.rocks/qenv';
+import * as smartagent from '@push.rocks/smartagent';
+import * as smartagentCompaction from '@push.rocks/smartagent/compaction';
+import * as smartai from '@push.rocks/smartai';
+import * as smartaiOpenAiChatGptAuth from '@push.rocks/smartai/openai-chatgpt-auth';
+import * as smartcli from '@push.rocks/smartcli';
+import * as smartconfig from '@push.rocks/smartconfig';
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartinteract from '@push.rocks/smartinteract';
+import * as smartpath from '@push.rocks/smartpath';
+
+export {
+  qenv,
+  smartagent,
+  smartagentCompaction,
+  smartai,
+  smartaiOpenAiChatGptAuth,
+  smartcli,
+  smartconfig,
+  smartdelay,
+  smartinteract,
+  smartpath,
+};