@git.zone/tsdoc 2.0.5 → 2.0.6

package/ts/classes.typedoc.ts

@@ -9,7 +9,8 @@ export class TypeDoc {
 
   // Static
   public static async isTypeDocDir(dirPathArg: string): Promise<boolean> {
-    return true;
+    return await plugins.fsInstance.file(plugins.path.join(dirPathArg, 'ts/index.ts')).exists()
+      || await plugins.fsInstance.file(plugins.path.join(dirPathArg, 'ts_web/index.ts')).exists();
   }
 
   // Instance
@@ -32,26 +33,48 @@ export class TypeDoc {
       include: [] as string[],
     };
     let startDirectory = '';
-    if (await plugins.fsInstance.directory(plugins.path.join(paths.cwd, './ts')).exists()) {
-      data.include.push(plugins.path.join(paths.cwd, './ts/**/*'));
+    if (await plugins.fsInstance.directory(plugins.path.join(this.typedocDirectory, './ts')).exists()) {
+      data.include.push(plugins.path.join(this.typedocDirectory, './ts/**/*'));
       startDirectory = 'ts';
     }
 
-    if (await plugins.fsInstance.directory(plugins.path.join(paths.cwd, './ts_web')).exists()) {
-      data.include.push(plugins.path.join(paths.cwd, './ts_web/**/*'));
+    if (await plugins.fsInstance.directory(plugins.path.join(this.typedocDirectory, './ts_web')).exists()) {
+      data.include.push(plugins.path.join(this.typedocDirectory, './ts_web/**/*'));
       if (!startDirectory) {
         startDirectory = 'ts_web';
       }
     }
 
-    await plugins.fsInstance.file(paths.tsconfigFile).encoding('utf8').write(JSON.stringify(data));
-    let targetDir = paths.publicDir;
+    if (!startDirectory) {
+      throw new Error(`No TypeDoc entrypoint found in ${this.typedocDirectory}`);
+    }
+
+    const tempDir = plugins.path.join(this.typedocDirectory, '.nogit', 'tsdoc');
+    const tempTsconfigFile = plugins.path.join(tempDir, 'tsconfig.json');
+    await plugins.fsInstance.directory(tempDir).recursive().create();
+    await plugins.fsInstance.file(tempTsconfigFile).encoding('utf8').write(JSON.stringify(data));
+    const publicDir = plugins.path.join(this.typedocDirectory, 'public');
+    let targetDir = publicDir;
     if (options?.publicSubdir) {
-      targetDir = plugins.path.join(targetDir, options.publicSubdir);
+      targetDir = plugins.path.resolve(plugins.path.join(targetDir, options.publicSubdir));
+      const resolvedPublicDir = plugins.path.resolve(publicDir);
+      if (!targetDir.startsWith(`${resolvedPublicDir}${plugins.path.sep}`) && targetDir !== resolvedPublicDir) {
+        throw new Error(`Invalid publicSubdir outside public directory: ${options.publicSubdir}`);
+      }
+    }
+    try {
+      const result = await this.smartshellInstance.exec(
+        `typedoc --tsconfig ${shellQuote(tempTsconfigFile)} --out ${shellQuote(targetDir)} ${shellQuote(plugins.path.join(this.typedocDirectory, startDirectory, 'index.ts'))}`,
+      );
+      if (result.exitCode !== 0) {
+        throw new Error('typedoc command failed.');
+      }
+    } finally {
+      if (await plugins.fsInstance.file(tempTsconfigFile).exists()) {
+        await plugins.fsInstance.file(tempTsconfigFile).delete();
+      }
     }
-    await this.smartshellInstance.exec(
-      `typedoc --tsconfig ${paths.tsconfigFile} --out ${targetDir} ${startDirectory}/index.ts`,
-    );
-    await plugins.fsInstance.file(paths.tsconfigFile).delete();
   }
 }
+
+const shellQuote = (value: string): string => `'${value.replaceAll("'", "'\\''")}'`;

package/ts/cli.ts

@@ -4,6 +4,54 @@ import { logger } from './logging.js';
 
 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();
+  return aidocInstance;
+};
+
+const getSmartcliArgv = (): string[] | undefined => {
+  if (process.argv.length === 0) return undefined;
+  if (process.argv[0] === process.execPath) return undefined;
+  return [process.execPath, 'tsdoc', ...process.argv];
+};
+
+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}`);
+    return;
+  }
+
+  const inspections = await plugins.smartaiOpenAiChatGptAuth.inspectOpenAiChatGptAuthSources({
+    sources: defaultChatGptAuthSources,
+  });
+  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}`);
+  }
+};
 
 export const run = async () => {
   const tsdocCli = new plugins.smartcli.Smartcli();
@@ -28,8 +76,7 @@ export const run = async () => {
   });
 
   tsdocCli.addCommand('aidoc').subscribe(async (argvArg) => {
-    const aidocInstance = new AiDoc();
-    await aidocInstance.start();
+    const aidocInstance = await createAiDoc(argvArg);
 
     logger.log('info', `Generating new readme...`);
     logger.log('info', `This may take some time...`);
@@ -39,9 +86,12 @@ export const run = async () => {
     await aidocInstance.buildDescription(paths.cwd);
   });
 
+  tsdocCli.addCommand('aidocs').subscribe(async (argvArg) => {
+    tsdocCli.triggerCommand('aidoc', argvArg);
+  });
+
   tsdocCli.addCommand('readme').subscribe(async (argvArg) => {
-    const aidocInstance = new AiDoc();
-    await aidocInstance.start();
+    const aidocInstance = await createAiDoc(argvArg);
 
     logger.log('info', `Generating new readme...`);
     logger.log('info', `This may take some time...`);
@@ -49,8 +99,7 @@ export const run = async () => {
   });
 
   tsdocCli.addCommand('description').subscribe(async (argvArg) => {
-    const aidocInstance = new AiDoc();
-    await aidocInstance.start();
+    const aidocInstance = await createAiDoc(argvArg);
 
     logger.log('info', `Generating new description and keywords...`);
     logger.log('info', `This may take some time...`);
@@ -58,17 +107,30 @@ export const run = async () => {
   });
 
   tsdocCli.addCommand('commit').subscribe(async (argvArg) => {
-    const aidocInstance = new AiDoc();
-    await aidocInstance.start();
+    const aidocInstance = await createAiDoc(argvArg);
 
     logger.log('info', `Generating commit message...`);
     logger.log('info', `This may take some time...`);
-    const commitObject = await aidocInstance.buildNextCommitObject(paths.cwd);
+    let commitObject: Awaited<ReturnType<AiDoc['buildNextCommitObject']>>;
+    try {
+      commitObject = await aidocInstance.buildNextCommitObject(paths.cwd);
+    } catch (error) {
+      if (error instanceof NoChangesError || (error as Error).name === 'NoChangesError') {
+        logger.log('info', 'No uncommitted changes found.');
+        console.log(JSON.stringify({ ok: true, noChanges: true }, null, 2));
+        return;
+      }
+      throw error;
+    }
 
     logger.log('ok', `Commit message generated:`);
     console.log(JSON.stringify(commitObject, null, 2));
   });
 
+  tsdocCli.addCommand('auth').subscribe(async (argvArg) => {
+    await handleAuthCommand(argvArg);
+  });
+
   tsdocCli.addCommand('test').subscribe((argvArg) => {
     tsdocCli.triggerCommand('typedoc', argvArg);
     process.on('exit', async () => {
@@ -76,5 +138,5 @@ export const run = async () => {
     });
   });
 
-  tsdocCli.startParse();
+  tsdocCli.startParse(getSmartcliArgv());
 };

package/ts/helpers.agenttools.ts

@@ -0,0 +1,125 @@
+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;
+      },
+    }),
+  };
+};

package/ts/index.ts

@@ -10,3 +10,4 @@ export const runCli = async () => {
 
 // exports
 export * from './classes.aidoc.js';
+export { NoChangesError } from './aidocs_classes/commit.js';

package/ts/plugins.ts

@@ -1,14 +1,17 @@
 // node native
+import * as fs from 'node:fs/promises';
 import * as path from 'path';
 
-export { path };
+export { fs, path };
 
 // pushrocks scope
 import * as smartconfig from '@push.rocks/smartconfig';
 import * as qenv from '@push.rocks/qenv';
 import * as smartagent from '@push.rocks/smartagent';
+import * as smartagentCompaction from '@push.rocks/smartagent/compaction';
 import * as smartagentTools from '@push.rocks/smartagent/tools';
 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 smartdelay from '@push.rocks/smartdelay';
 import * as smartfile from '@push.rocks/smartfile';
@@ -25,8 +28,10 @@ export {
   smartconfig,
   qenv,
   smartagent,
+  smartagentCompaction,
   smartagentTools,
   smartai,
+  smartaiOpenAiChatGptAuth,
   smartcli,
   smartdelay,
   smartfile,