@plosson/agentio 0.3.2 → 0.4.1

package/src/types/gdocs.ts

@@ -0,0 +1,28 @@
+export interface GDocsCredentials {
+  accessToken: string;
+  refreshToken?: string;
+  expiryDate?: number;
+  tokenType: string;
+  scope?: string;
+  email: string;
+}
+
+export interface GDocsDocument {
+  id: string;
+  title: string;
+  owner?: string;
+  createdTime?: string;
+  modifiedTime?: string;
+  webViewLink: string;
+}
+
+export interface GDocsListOptions {
+  limit?: number;
+  query?: string;
+}
+
+export interface GDocsCreateResult {
+  id: string;
+  title: string;
+  webViewLink: string;
+}

package/src/types/gdrive.ts

@@ -0,0 +1,81 @@
+export type GDriveAccessLevel = 'readonly' | 'full';
+
+export interface GDriveCredentials {
+  accessToken: string;
+  refreshToken?: string;
+  expiryDate?: number;
+  tokenType: string;
+  scope?: string;
+  email: string;
+  accessLevel: GDriveAccessLevel;
+}
+
+export interface GDriveFile {
+  id: string;
+  name: string;
+  mimeType: string;
+  size?: number;
+  createdTime?: string;
+  modifiedTime?: string;
+  owners?: string[];
+  parents?: string[];
+  webViewLink?: string;
+  webContentLink?: string;
+  starred: boolean;
+  trashed: boolean;
+  shared: boolean;
+  description?: string;
+}
+
+export interface GDriveListOptions {
+  limit?: number;
+  folderId?: string;
+  query?: string;
+  orderBy?: string;
+  includeTrash?: boolean;
+}
+
+export interface GDriveSearchOptions {
+  query: string;
+  mimeType?: string;
+  limit?: number;
+  folderId?: string;
+}
+
+export interface GDriveFolderListOptions {
+  limit?: number;
+  parentId?: string;
+  query?: string;
+}
+
+export interface GDriveDownloadOptions {
+  fileIdOrUrl: string;
+  outputPath: string;
+  exportFormat?: GDriveExportFormat;
+}
+
+export interface GDriveDownloadResult {
+  filename: string;
+  path: string;
+  size: number;
+  mimeType: string;
+}
+
+// Export formats for Google Workspace files
+export type GDriveExportFormat = 'pdf' | 'docx' | 'xlsx' | 'csv' | 'pptx' | 'txt' | 'html' | 'odt' | 'ods' | 'odp' | 'rtf' | 'tsv' | 'png' | 'jpeg' | 'svg';
+
+export interface GDriveUploadOptions {
+  filePath: string;
+  name?: string;
+  folderId?: string;
+  mimeType?: string;
+  convert?: boolean;
+}
+
+export interface GDriveUploadResult {
+  id: string;
+  name: string;
+  mimeType: string;
+  size: number;
+  webViewLink?: string;
+}

package/src/utils/client-factory.ts

@@ -1,5 +1,5 @@
 import { getCredentials } from '../auth/token-store';
-import { getProfile } from '../config/config-manager';
+import { resolveProfile } from '../config/config-manager';
 import { CliError } from './errors';
 import type { ServiceName } from '../types/config';
 
@@ -10,6 +10,7 @@ export interface ClientFactoryConfig<TCredentials, TClient> {
 
 /**
  * Creates a type-safe client getter function for a service.
+ * Profile is optional - if only one profile exists, it will be used automatically.
  *
  * Usage:
  * ```typescript
@@ -21,18 +22,20 @@ export interface ClientFactoryConfig<TCredentials, TClient> {
  */
 export function createClientGetter<TCredentials, TClient>(
   config: ClientFactoryConfig<TCredentials, TClient>
-): (profileName: string) => Promise<{ client: TClient; profile: string }> {
+): (profileName?: string) => Promise<{ client: TClient; profile: string }> {
   const { service, createClient } = config;
 
-  return async (profileName: string): Promise<{ client: TClient; profile: string }> => {
-    const profile = await getProfile(service, profileName);
+  return async (profileName?: string): Promise<{ client: TClient; profile: string }> => {
+    const { profile, error } = await resolveProfile(service, profileName);
 
     if (!profile) {
-      throw new CliError(
-        'PROFILE_NOT_FOUND',
-        `Profile "${profileName}" not found for ${service}`,
-        `Run: agentio ${service} profile add`
-      );
+      if (error === 'none') {
+        throw new CliError('PROFILE_NOT_FOUND', `No ${service} profile configured`, `Run: agentio ${service} profile add`);
+      }
+      if (error === 'multiple') {
+        throw new CliError('PROFILE_NOT_FOUND', `Multiple ${service} profiles exist`, 'Specify --profile <name>');
+      }
+      throw new CliError('PROFILE_NOT_FOUND', `Profile "${profileName}" not found for ${service}`, `Run: agentio ${service} profile add`);
     }
 
     const credentials = await getCredentials<TCredentials>(service, profile);

package/src/utils/interactive.ts

@@ -0,0 +1,145 @@
+import {
+  select,
+  checkbox,
+  confirm as inquirerConfirm,
+  input,
+} from '@inquirer/prompts';
+import { CliError } from './errors';
+
+export interface SelectChoice<T> {
+  name: string;
+  value: T;
+  description?: string;
+}
+
+export interface CheckboxChoice<T> {
+  name: string;
+  value: T;
+  checked?: boolean;
+}
+
+/**
+ * Check if running in an interactive terminal.
+ */
+export function isInteractive(): boolean {
+  return process.stdin.isTTY === true;
+}
+
+/**
+ * Interactive select prompt. Falls back to default or throws if not in TTY.
+ */
+export async function interactiveSelect<T>(options: {
+  message: string;
+  choices: SelectChoice<T>[];
+  default?: T;
+}): Promise<T> {
+  if (!isInteractive()) {
+    if (options.default !== undefined) {
+      return options.default;
+    }
+    throw new CliError(
+      'INVALID_PARAMS',
+      'Interactive input required but not running in terminal',
+      'Run this command in an interactive terminal'
+    );
+  }
+
+  return select({
+    message: options.message,
+    choices: options.choices,
+    default: options.default,
+    loop: false,
+  });
+}
+
+/**
+ * Interactive checkbox (multi-select) prompt. Falls back to default or throws if not in TTY.
+ */
+export async function interactiveCheckbox<T>(options: {
+  message: string;
+  choices: CheckboxChoice<T>[];
+  required?: boolean;
+}): Promise<T[]> {
+  if (!isInteractive()) {
+    // Return all checked items as default
+    const defaults = options.choices.filter((c) => c.checked).map((c) => c.value);
+    if (defaults.length > 0 || !options.required) {
+      return defaults;
+    }
+    throw new CliError(
+      'INVALID_PARAMS',
+      'Interactive input required but not running in terminal',
+      'Run this command in an interactive terminal'
+    );
+  }
+
+  const result = await checkbox({
+    message: options.message,
+    choices: options.choices,
+    loop: false,
+  });
+
+  if (options.required && result.length === 0) {
+    throw new CliError('INVALID_PARAMS', 'At least one option must be selected');
+  }
+
+  return result;
+}
+
+/**
+ * Interactive confirm prompt. Falls back to default or throws if not in TTY.
+ */
+export async function interactiveConfirm(options: {
+  message: string;
+  default?: boolean;
+}): Promise<boolean> {
+  if (!isInteractive()) {
+    if (options.default !== undefined) {
+      return options.default;
+    }
+    throw new CliError(
+      'INVALID_PARAMS',
+      'Interactive input required but not running in terminal',
+      'Run this command in an interactive terminal'
+    );
+  }
+
+  return inquirerConfirm({
+    message: options.message,
+    default: options.default,
+  });
+}
+
+/**
+ * Interactive text input prompt. Falls back to default or throws if not in TTY.
+ */
+export async function interactiveInput(options: {
+  message: string;
+  default?: string;
+  required?: boolean;
+}): Promise<string> {
+  if (!isInteractive()) {
+    if (options.default !== undefined) {
+      return options.default;
+    }
+    if (!options.required) {
+      return '';
+    }
+    throw new CliError(
+      'INVALID_PARAMS',
+      'Interactive input required but not running in terminal',
+      'Run this command in an interactive terminal'
+    );
+  }
+
+  const result = await input({
+    message: options.message,
+    default: options.default,
+  });
+
+  if (options.required && !result.trim()) {
+    throw new CliError('INVALID_PARAMS', 'Input is required');
+  }
+
+  return result;
+}

package/src/utils/output.ts

@@ -1,5 +1,7 @@
 import type { GmailMessage, GmailAttachmentInfo } from '../types/gmail';
 import type { GChatMessage, GChatSpace } from '../types/gchat';
+import type { GDocsDocument, GDocsCreateResult } from '../types/gdocs';
+import type { GDriveFile, GDriveDownloadResult, GDriveUploadResult } from '../types/gdrive';
 import type { JiraProject, JiraIssue, JiraTransition, JiraCommentResult, JiraTransitionResult } from '../types/jira';
 import type { SlackSendResult } from '../types/slack';
 import type { RssFeed, RssArticle } from '../types/rss';
@@ -373,3 +375,110 @@ export function printDiscourseTopic(topic: DiscourseTopicDetail): void {
     console.log(content);
   }
 }
+
+// Google Docs specific formatters
+export function printGDocsList(docs: GDocsDocument[]): void {
+  if (docs.length === 0) {
+    console.log('No documents found');
+    return;
+  }
+
+  console.log(`Documents (${docs.length})\n`);
+
+  for (let i = 0; i < docs.length; i++) {
+    const doc = docs[i];
+    console.log(`[${i + 1}] ${doc.title}`);
+    console.log(`    ID: ${doc.id}`);
+    if (doc.owner) console.log(`    Owner: ${doc.owner}`);
+    if (doc.modifiedTime) console.log(`    Modified: ${doc.modifiedTime}`);
+    console.log(`    Link: ${doc.webViewLink}`);
+    console.log('');
+  }
+}
+
+export function printGDocCreated(result: GDocsCreateResult): void {
+  console.log('Document created');
+  console.log(`ID: ${result.id}`);
+  console.log(`Title: ${result.title}`);
+  console.log(`Link: ${result.webViewLink}`);
+}
+
+// Google Drive specific formatters
+function getShortMimeType(mimeType: string): string {
+  const shortTypes: Record<string, string> = {
+    'application/vnd.google-apps.folder': 'folder',
+    'application/vnd.google-apps.document': 'gdoc',
+    'application/vnd.google-apps.spreadsheet': 'gsheet',
+    'application/vnd.google-apps.presentation': 'gslide',
+    'application/pdf': 'pdf',
+    'image/png': 'png',
+    'image/jpeg': 'jpg',
+    'text/plain': 'txt',
+    'application/zip': 'zip',
+  };
+  if (shortTypes[mimeType]) return shortTypes[mimeType];
+  if (mimeType.startsWith('image/')) return 'image';
+  if (mimeType.startsWith('video/')) return 'video';
+  if (mimeType.startsWith('audio/')) return 'audio';
+  if (mimeType.startsWith('text/')) return 'text';
+  return 'file';
+}
+
+export function printGDriveFileList(files: GDriveFile[], title: string = 'Files'): void {
+  if (files.length === 0) {
+    console.log('No files found');
+    return;
+  }
+
+  console.log(`${title} (${files.length})\n`);
+
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    const isFolder = file.mimeType === 'application/vnd.google-apps.folder';
+    const typeIndicator = isFolder ? '[folder]' : `[${getShortMimeType(file.mimeType)}]`;
+    const flags: string[] = [];
+    if (file.starred) flags.push('*');
+    if (file.shared) flags.push('shared');
+    const flagStr = flags.length > 0 ? ` (${flags.join(', ')})` : '';
+
+    console.log(`[${i + 1}] ${file.name} ${typeIndicator}${flagStr}`);
+    console.log(`    ID: ${file.id}`);
+    if (file.size) console.log(`    Size: ${formatBytes(file.size)}`);
+    if (file.owners?.length) console.log(`    Owner: ${file.owners[0]}`);
+    if (file.modifiedTime) console.log(`    Modified: ${file.modifiedTime}`);
+    if (file.webViewLink) console.log(`    Link: ${file.webViewLink}`);
+    console.log('');
+  }
+}
+
+export function printGDriveFile(file: GDriveFile): void {
+  console.log(`ID: ${file.id}`);
+  console.log(`Name: ${file.name}`);
+  console.log(`Type: ${file.mimeType}`);
+  if (file.size) console.log(`Size: ${formatBytes(file.size)}`);
+  if (file.description) console.log(`Description: ${file.description}`);
+  if (file.owners?.length) console.log(`Owners: ${file.owners.join(', ')}`);
+  if (file.parents?.length) console.log(`Parents: ${file.parents.join(', ')}`);
+  console.log(`Starred: ${file.starred ? 'yes' : 'no'}`);
+  console.log(`Shared: ${file.shared ? 'yes' : 'no'}`);
+  console.log(`Trashed: ${file.trashed ? 'yes' : 'no'}`);
+  if (file.createdTime) console.log(`Created: ${file.createdTime}`);
+  if (file.modifiedTime) console.log(`Modified: ${file.modifiedTime}`);
+  if (file.webViewLink) console.log(`View: ${file.webViewLink}`);
+  if (file.webContentLink) console.log(`Download: ${file.webContentLink}`);
+}
+
+export function printGDriveDownloaded(result: GDriveDownloadResult): void {
+  console.log(`Downloaded: ${result.filename}`);
+  console.log(`  Path: ${result.path}`);
+  console.log(`  Size: ${formatBytes(result.size)}`);
+  console.log(`  Type: ${result.mimeType}`);
+}
+
+export function printGDriveUploaded(result: GDriveUploadResult): void {
+  console.log(`Uploaded: ${result.name}`);
+  console.log(`  ID: ${result.id}`);
+  console.log(`  Size: ${formatBytes(result.size)}`);
+  console.log(`  Type: ${result.mimeType}`);
+  if (result.webViewLink) console.log(`  Link: ${result.webViewLink}`);
+}