AIチャットで完結。MastraとActiveReportsJSで実現する日報AIエージェント（2）

npm install mastra@latest @mastra/core@latest @mastra/loggers@latest @mastra/memory@latest @mastra/libsql@latest

npx @mastra/codemod@latest v1

npm install @mastra/observability@latest

import { Mastra } from '@mastra/core/mastra';
import { AzureOpenAIGateway } from '@mastra/core/llm';
import { PinoLogger } from '@mastra/loggers';
import { LibSQLStore } from '@mastra/libsql';
import { Observability, DefaultExporter, CloudExporter, SensitiveDataFilter } from '@mastra/observability';
import { weatherWorkflow } from './workflows/weather-workflow';
import { weatherAgent } from './agents/weather-agent';


export const mastra = new Mastra({
  gateways: {
    azureOpenAI: new AzureOpenAIGateway({
      resourceName: process.env.AZURE_OPENAI_RESOURCE_NAME!,  //環境変数の追加が必要です。
      apiVersion: process.env.AZURE_OPENAI_API_VERSION!,
      apiKey: process.env.AZURE_OPENAI_KEY!,
      deployments: ["gpt-4.1"],
    }),
  },  
  workflows: { weatherWorkflow },
  agents: { weatherAgent },
  /* FIXME(mastra): Add a unique `id` parameter. See: https://mastra.ai/guides/migrations/upgrade-to-v1/mastra#required-id-parameter-for-all-mastra-primitives */
  storage: new LibSQLStore({
    // stores observability, scores, ... into memory storage, if it needs to persist, change to file:../mastra.db
    id: 'mastra-storage',
    url: ":memory:",
  }),
  logger: new PinoLogger({
    name: 'Mastra', 
    level: 'info',
  }),
  observability: new Observability({
    configs: {
      default: {
        serviceName: 'mastra',
        exporters: [
          new DefaultExporter(), // Persists traces to storage for Mastra Studio
          new CloudExporter(), // Sends traces to Mastra Cloud (if MASTRA_CLOUD_ACCESS_TOKEN is set)
        ],
        spanOutputProcessors: [
          new SensitiveDataFilter(), // Redacts sensitive data like passwords, tokens, keys
        ],
      },
    },
  }),    
  // telemetry: {
  //   // Telemetry is deprecated and will be removed in the Nov 4th release
  //   enabled: false, 
  // },
  // observability: {
  //   // Enables DefaultExporter and CloudExporter for AI tracing
  //   default: { enabled: true }, 
  // },
});

import { Agent } from '@mastra/core/agent';
import { Memory } from '@mastra/memory';
import { LibSQLStore } from '@mastra/libsql';
import { weatherTool } from '../tools/weather-tool';
//import { createAzure } from '@ai-sdk/azure';

// const azure = createAzure({
//   useDeploymentBasedUrls: true,
//   baseURL: process.env.AZURE_OPENAI_ENDPOINT!,
//   apiVersion: process.env.AZURE_OPENAI_API_VERSION!,
//   apiKey: process.env.AZURE_OPENAI_KEY!,
// });

/* FIXME(mastra): Add a unique `id` parameter. See: https://mastra.ai/guides/migrations/upgrade-to-v1/mastra#required-id-parameter-for-all-mastra-primitives */ /*日本語訳：一意の id パラメータを追加してください。詳細は次を参照してください*/
export const weatherAgent = new Agent({
  id: 'weather-agent', //追加
  name: 'Weather Agent',
  instructions: `
      You are a helpful weather assistant that provides accurate weather information and can help planning activities based on the weather.

      Your primary function is to help users get weather details for specific locations. When responding:
      - Always ask for a location if none is provided
      - If the location name isn't in English, please translate it
      - If giving a location with multiple parts (e.g. "New York, NY"), use the most relevant part (e.g. "New York")
      - Include relevant details like humidity, wind conditions, and precipitation
      - Keep responses concise but informative
      - If the user asks for activities and provides the weather forecast, suggest activities based on the weather forecast.
      - If the user asks for activities, respond in the format they request.

      Use the weatherTool to fetch current weather data.
`,
  //model: azure('gpt-4.1'),  //← 変更 model: 'openai/gpt-4o-mini',
  model: "azure-openai/gpt-4.1",
  tools: { weatherTool },

  memory: new Memory({
    /* FIXME(mastra): Add a unique `id` parameter. See: https://mastra.ai/guides/migrations/upgrade-to-v1/mastra#required-id-parameter-for-all-mastra-primitives *//*日本語訳：一意の id パラメータを追加してください。詳細は次を参照してください*/
    storage: new LibSQLStore({
      id: 'weather-agent-memory', //追加
      url: 'file:../mastra.db', // path is relative to the .mastra/output directory
    }),
  }),
});

import { createTool } from '@mastra/core/tools';
import { z } from 'zod';

interface GeocodingResponse {
  results: {
    latitude: number;
    longitude: number;
    name: string;
  }[];
}
interface WeatherResponse {
  current: {
    time: string;
    temperature_2m: number;
    apparent_temperature: number;
    relative_humidity_2m: number;
    wind_speed_10m: number;
    wind_gusts_10m: number;
    weather_code: number;
  };
}

export const weatherTool = createTool({
  id: 'get-weather',
  description: 'Get current weather for a location',
  inputSchema: z.object({
    location: z.string().describe('City name'),
  }),
  outputSchema: z.object({
    temperature: z.number(),
    feelsLike: z.number(),
    humidity: z.number(),
    windSpeed: z.number(),
    windGust: z.number(),
    conditions: z.string(),
    location: z.string(),
  }),
  execute: async ({ location }) => {
    return await getWeather(location);
  },
});

const getWeather = async (location: string) => {
  const geocodingUrl = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(location)}&count=1`;
  const geocodingResponse = await fetch(geocodingUrl);
  const geocodingData = (await geocodingResponse.json()) as GeocodingResponse;

  if (!geocodingData.results?.[0]) {
    throw new Error(`Location '${location}' not found`);
  }

  const { latitude, longitude, name } = geocodingData.results[0];

  const weatherUrl = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}¤t=temperature_2m,apparent_temperature,relative_humidity_2m,wind_speed_10m,wind_gusts_10m,weather_code`;

  const response = await fetch(weatherUrl);
  const data = (await response.json()) as WeatherResponse;

  return {
    temperature: data.current.temperature_2m,
    feelsLike: data.current.apparent_temperature,
    humidity: data.current.relative_humidity_2m,
    windSpeed: data.current.wind_speed_10m,
    windGust: data.current.wind_gusts_10m,
    conditions: getWeatherCondition(data.current.weather_code),
    location: name,
  };
};

function getWeatherCondition(code: number): string {
  const conditions: Record<number, string> = {
    0: 'Clear sky',
    1: 'Mainly clear',
    2: 'Partly cloudy',
    3: 'Overcast',
    45: 'Foggy',
    48: 'Depositing rime fog',
    51: 'Light drizzle',
    53: 'Moderate drizzle',
    55: 'Dense drizzle',
    56: 'Light freezing drizzle',
    57: 'Dense freezing drizzle',
    61: 'Slight rain',
    63: 'Moderate rain',
    65: 'Heavy rain',
    66: 'Light freezing rain',
    67: 'Heavy freezing rain',
    71: 'Slight snow fall',
    73: 'Moderate snow fall',
    75: 'Heavy snow fall',
    77: 'Snow grains',
    80: 'Slight rain showers',
    81: 'Moderate rain showers',
    82: 'Violent rain showers',
    85: 'Slight snow showers',
    86: 'Heavy snow showers',
    95: 'Thunderstorm',
    96: 'Thunderstorm with slight hail',
    99: 'Thunderstorm with heavy hail',
  };
  return conditions[code] || 'Unknown';
}

AZURE_OPENAI_ENDPOINT=https://your-end-point/openai
AZURE_OPENAI_API_VERSION=2025-01-01-preview
AZURE_OPENAI_KEY=your-api-key
AZURE_OPENAI_RESOURCE_NAME=your-resource-name

mastra dev --dir ./mastra

npm install better-sqlite3 drizzle-orm drizzle-kit
npm install -D @types/better-sqlite3

import type { Config } from 'drizzle-kit';

export default {
  schema: './database/schema.ts',
  out: './database/migrations',
  dialect: 'sqlite',
  dbCredentials: {
    url: './database/workreports.db',
  },
} satisfies Config;

import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core';
import { sql } from 'drizzle-orm';

export const users = sqliteTable('users', {
  id: integer('id').primaryKey({ autoIncrement: true }),
  name: text('name').notNull(),
  email: text('email').notNull().unique(),
  createdAt: text('created_at').notNull().default(sql`CURRENT_TIMESTAMP`),
});

export const dailyReports = sqliteTable('daily_reports', {
    id: integer('id').primaryKey({ autoIncrement: true }),
    userId: integer('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
    reportDate: text('report_date').notNull(),
    workContent: text('work_content').notNull(),
    issues: text('issues'),
    nextActions: text('next_actions'),
    weather: text('weather'),
    temperature: integer('temperature'),
    weatherSource: text('weather_source'),
    rawInput: text('raw_input'),
    createdAt: text('created_at').notNull().default(sql`CURRENT_TIMESTAMP`),
    updatedAt: text('updated_at').notNull().default(sql`CURRENT_TIMESTAMP`),
});

npx drizzle-kit generate 

npx drizzle-kit migrate

npx drizzle-kit studio

import Database from 'better-sqlite3';
import { drizzle } from 'drizzle-orm/better-sqlite3';
import path from 'path';
import fs from 'fs';
import * as schema from './schema';

/**
 * プロジェクトルートディレクトリを取得
 * 
 * 問題：同じ database モジュールが開発時と本番時で異なる場所から実行される
 * - 開発時: ソースコード（TypeScript）から直接実行
 * - 本番時: コンパイル済みコード（.mastra/output/）から実行
 * 
 * 前提条件：
 * - ローカル開発時（npm run dev）:
 *   __filename は .mastra を含まないパス
 *   → process.cwd() でプロジェクトルートを取得
 * 
 * - Mastraビルド・本番時（npx mastra dev または npm run build → start）:
 *   __filename は .mastra/output 配下のパス
 *   例）project-root/.mastra/output/xxx/database/index.js
 *   → 3階層上に遡ってプロジェクトルートに到達
 * 
 * 処理ロジック：
 * - .mastra を含むパスの場合: 3階層上に遡る (../../../../) でプロジェクトルートに到達
 * - そうでない場合: process.cwd() をプロジェクトルートとする
 */
const getProjectRoot = (): string => {
  // Mastraでビルドされたファイルの場合、__filename から推定
  if (typeof __filename !== 'undefined' && __filename.includes('.mastra')) {
    return path.resolve(__filename, '../../../..');
  }
  
  // ローカル開発時はプロセスの作業ディレクトリをプロジェクトルートとする
  return process.cwd();
};

const projectRoot = getProjectRoot();
const dataDir = path.join(projectRoot, 'database');

// フォルダが存在しなければ作成
if (!fs.existsSync(dataDir)) {
  fs.mkdirSync(dataDir, { recursive: true });
}

const dbPath = path.join(dataDir, 'workreports.db');

// SQLite データベース接続
const sqlite = new Database(dbPath);

// テーブル確認
try {
  sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table'").all();
} catch {
  // ignore
}

// Drizzle ORM インスタンス
export const db = drizzle(sqlite, { schema });

// データベース接続テスト
export function testConnection() {
  try {
    sqlite.prepare('SELECT 1').get();
    return true;
  } catch {
    return false;
  }
}

import { createTool } from '@mastra/core/tools';
import { z } from 'zod';
import { db } from '@/database';
import * as schema from '@/database/schema';
import { eq } from 'drizzle-orm';

/**
 * ========== 概要 ==========
 * 
 * このファイルは Mastra エージェント用の汎用 CRUD ツールを提供します。
 * AI エージェントがデータベースに対して CREATE / READ / UPDATE / DELETE 操作
 * を実行できるようにします。
 */

/**
 * database/schema.ts に定義されているテーブル名の型
 * 
 * 使用例：
 * - 'daily_reports': 日報テーブル
 * - 'users': ユーザーテーブル
 * - など schema.ts で定義されたテーブルすべて
 */
type TableName = keyof typeof schema;

/**
 * ========== 汎用 CRUD ツール ==========
 * 
 * 設計思想：
 * - 入力値の妥当性チェックは Drizzle ORM のスキーマ制約に委譲
 *   （NOT NULL、UNIQUE、FOREIGN KEY などの制約）
 * - ツール側では try/catch で例外をハンドル
 * - エラーメッセージはユーザーフレンドリーに変換
 * 
 * 対応操作：
 * 1. CREATE: 新規記録を作成
 * 2. READ: 記録を取得（WHERE条件対応）
 * 3. UPDATE: 記録を更新（id指定必須）
 * 4. DELETE: 記録を削除（id指定必須）
 */
export const crudTool = createTool({
  id: 'crud-tool',
  description: 'Generic CRUD tool based on Drizzle schema constraints',

  /**
   * ========== 入力スキーマ ==========
   * 
   * @param operation - 実行する操作
   *   - 'create': レコード新規作成、data パラメータを使用
   *   - 'read': レコード検索、where パラメータで条件指定可能
   *   - 'update': レコード更新、where.id で対象を指定、data で新値を指定
   *   - 'delete': レコード削除、where.id で対象を指定
   * 
   * @param table - テーブル名（schema.ts で定義されている必要があります）
   * 
   * @param data - INSERT/UPDATE する値
   *   例）{ name: 'John', email: 'john@example.com' }
   * 
   * @param where - WHERE 条件（通常は id を指定）
   *   例）{ id: 1 }, { id: 5 }
   */
  inputSchema: z.object({
    operation: z.enum(['create', 'read', 'update', 'delete']),
    table: z.string(),
    data: z.record(z.string(), z.unknown()).optional(),
    where: z.record(z.string(), z.unknown()).optional(),
  }),

  /**
   * ========== 出力スキーマ ==========
   * 
   * @param success - 操作が成功したかどうか
   * @param data - 操作結果のデータ（CREATE/READ/UPDATE で返却）
   * @param message - エラーメッセージ（成功時は省略）
   */
  outputSchema: z.object({
    success: z.boolean(),
    data: z.unknown().optional(),
    message: z.string().optional(),
  }),

  /**
   * ========== メイン処理 ==========
   */
  execute: async ({ operation, table, data, where }) => {

    // ========== テーブルの存在確認 ==========
    const targetTable = schema[table as TableName];
    if (!targetTable) {
      return { success: false, message: `Unknown table: ${table}` };
    }

    // ========== ID カラムの検出 ==========
    // UPDATE/DELETE 操作で WHERE 條件として id を使用するため
    // 対象テーブルの id カラムを動的に取得
    type TargetTableType = typeof targetTable;
    const idColumn = ('id' in targetTable ? (targetTable as { id: unknown }).id : null) as (TargetTableType extends { id: infer T } ? T : null);

    try {
      switch (operation) {
        /**
         * ========== CREATE 操作 ==========
         * 新規レコードをテーブルに挿入します
         * 
         * 処理フロー：
         * 1. INSERT 文を生成
         * 2. data パラメータの値を使用
         * 3. 新規作成されたレコードを RETURNING で返す
         * 4. スキーマの制約違反がある場合は error catch へ
         * 
         * エラー例：
         * - NOT NULL 制約違反
         * - UNIQUE 制約違反（重複した値）
         * - 型の不一致
         */
        case 'create': {
          const result = await db
            .insert(targetTable)
            .values(data ?? {})
            .returning();

          return { success: true, data: result };
        }

        /**
         * ========== READ 操作 ==========
         * テーブルからレコードを検索します
         * 
         * 処理フロー：
         * 1. where.id が指定されている場合：
         *    - そのID のレコードのみを取得
         * 2. where.id が指定されていない場合：
         *    - テーブル全体を取得
         * 
         * 使用例：
         * - { table: 'daily_reports', operation: 'read', where: { id: 1 } }
         *   → ID=1 の日報を1件取得
         * 
         * - { table: 'daily_reports', operation: 'read' }
         *   → 全日報を取得
         */
        case 'read': {
          let result;
          if (idColumn && where?.id !== undefined) {
            result = await db.select().from(targetTable).where(eq(idColumn, Number(where.id)));
          } else {
            result = await db.select().from(targetTable);
          }
          return { success: true, data: result };
        }

        /**
         * ========== UPDATE 操作 ==========
         * 既存レコードを更新します
         * 
         * 必須条件：
         * - where.id が必ず指定される必要があります
         *   （複数レコードの同時更新を防ぐため）
         * 
         * 処理フロー：
         * 1. where.id から対象レコードを特定
         * 2. data パラメータの値で上書き
         * 3. 更新後のレコードを RETURNING で返す
         * 4. id の不在または型の不一致は error へ
         * 
         * エラー例：
         * - id が指定されていない
         * - UNIQUE 制約違反
         * - データ型の不一致
         */
        case 'update': {
          if (!idColumn || where?.id === undefined) {
            throw new Error('id is required for update');
          }

          const result = await db
            .update(targetTable)
            .set(data ?? {})
            .where(eq(idColumn, Number(where.id)))
            .returning();

          return { success: true, data: result };
        }

        /**
         * ========== DELETE 操作 ==========
         * 指定したレコードを削除します
         * 
         * 必須条件：
         * - where.id が必ず指定される必要があります
         *   （複数レコードの誤削除を防ぐため）
         * 
         * 処理フロー：
         * 1. where.id から対象レコードを特定
         * 2. そのレコードを削除
         * 3. 削除対象が見つからない場合も成功として返す
         * 4. id の不在は error へ
         * 
         * 注意：
         * - 削除後のデータ復旧はできません
         * - FOREIGN KEY 制約の対象になっている場合は削除失敗
         */
        case 'delete': {
          if (!idColumn || where?.id === undefined) {
            throw new Error('id is required for delete');
          }

          await db
            .delete(targetTable)
            .where(eq(idColumn, Number(where.id)));

          return { success: true };
        }
      }
    } catch (error) {
      return {
        success: false,
        message: formatDbError(error),
      };
    }
  },
});

/**
 * ========== エラーメッセージの変換 ==========
 * 
 * Drizzle ORM / SQLite が返すエラーメッセージを解釈し、
 * ユーザーフレンドリーな日本語メッセージに変換します
 * 
 * 対応するエラータイプ：
 * 
 * 1. NOT NULL 制約違反
 *    - 必須項目が空白で送信された
 *    - 例：{ name: null }
 * 
 * 2. UNIQUE 制約違反
 *    - 重複する値をINSERT/UPDATEしようとした
 *    - 例：メールアドレスが既に登録されている
 * 
 * 3. FOREIGN KEY 制約違反
 *    - 関連する親レコードが存在しない
 *    - 例：存在しないユーザーID を参照している
 * 
 * 4. CHECK 制約違反
 *    - カスタム検証ルールに違反している
 *    - 例：年齢が負の数
 * 
 * @param error - Drizzle ORM から投げられたエラーオブジェクト
 * @returns ユーザーフレンドリーなエラーメッセージ
 */
function formatDbError(error: unknown): string {
  if (!(error instanceof Error)) {
    return 'Unknown database error';
  }

  const msg = error.message;

  if (msg.includes('NOT NULL')) {
    return '必須項目が不足しています';
  }
  if (msg.includes('UNIQUE')) {
    return '一意制約に違反しています';
  }
  if (msg.includes('FOREIGN KEY')) {
    return '関連データが存在しません';
  }
  if (msg.includes('CHECK')) {
    return '入力値が制約条件を満たしていません';
  }

  return msg;
}

import { createTool } from '@mastra/core/tools';
import { z } from 'zod';
import { promises as fs } from 'fs';
import { join, resolve, dirname } from 'path';
import { fileURLToPath } from 'url';

// レポートデータの型定義（任意のキーと値のペアを持つオブジェクト）
type ReportData = Record<string, unknown>;

// 現在のファイルのディレクトリを取得（ES モジュール環境用）
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);

// レポート読み込み結果の型定義
type ReportResult = {
  report: ReportData;           // パースされたレポート定義
  fileName: string;              // ロードされた帳票レイアウトファイルの名前
  parameters?: Record<string, unknown>; // レポートに渡されるパラメータ
};

/**
 * ========================================
 * レポート生成ツール
 * ========================================
 *
 * 機能：RDLX-JSON形式のレポート定義ファイルを読み込み、
 *       ActiveReports.jsビューアで表示可能なレポート定義を返す
 *
 * 用途：複数のレポートテンプレートから、指定されたレポートを
 *       動的にロードして エージェントに提供する
 */
export const reportTool = createTool({
  id: 'reports-tool',
  description: 'RDLX-JSON形式のレポート定義ファイルをreportsフォルダからロードして、ActiveReports.jsビューアで表示可能なレポート定義を返します。',

  // ========== 入力スキーマ（ユーザーやエージェントからの入力） ==========
  inputSchema: z.object({
    reportName: z.string().describe('帳票レイアウトファイルの名前（拡張子なし）。例: "weather-report"、"sales-report"、"user-list"'),
    parameters: z.record(z.string(), z.any()).optional().describe('レポートに渡すパラメータ（ユーザーデータなど）'),
  }),

  // ========== 出力スキーマ（このツールの戻り値） ==========
  outputSchema: z.object({
    // レポートはJSON文字列で返される（テキスト分割を避けるため）
    // 内部用途に備えて、パースされたオブジェクトも `reportObject` で提供される
    report: z.string().describe('レポート定義のJSON文字列（一塊の形式）'),
    reportObject: z.record(z.string(), z.unknown()).optional().describe('パースされたレポートオブジェクト（内部用）'),
    fileName: z.string().describe('ロードされた帳票レイアウトファイル名'),
    parameters: z.record(z.string(), z.unknown()).optional().describe('ビューアに渡すレポートパラメータ'),
  }),

  // ========== メイン処理 ==========
  execute: async (args: unknown) => {
    /**
     * Mastra や createTool からツール入力を受け取る際、複数の形式が考えられるため、
     * それぞれのケースに対応する処理を行う：
     * 1. 直接オブジェクトで渡される場合
     * 2. { context: {...} } の形で渡される場合
     * 3. JSON文字列で渡される場合
     * 4. { argsJson: '...' } の形で渡される場合
     */
    let payload: unknown = args;

    // ========== パターン1: JSON文字列として渡された場合の処理 ==========
    if (typeof payload === 'string') {
      try {
        payload = JSON.parse(payload);
      } catch {
        // パースに失敗しても続行（下流のバリデーションでエラーが出る）
      }
    }

    // ========== パターン2: { argsJson: '...' } の形で渡された場合の処理 ==========
    // 一部のランタイムでは、引数がこのフォーマットで包装されることがある
    const argsObj = args as Record<string, unknown> | null;
    if (!payload && argsObj?.argsJson) {
      try {
        payload = JSON.parse(argsObj.argsJson as string);
      } catch {
        // パースに失敗した場合はpayloadのままで続行
      }
    }

    // ========== パターン3: { context: {...} } の形で渡された場合の処理 ==========
    // この場合は、context内に実際の引数が含まれているため抽出する
    const payloadObj = payload as Record<string, unknown> | null;
    if (payloadObj?.context && typeof payloadObj.context === 'object') {
      payload = { ...payloadObj.context };
    }

    const finalPayload = payload as Record<string, unknown> | null;
    const reportName = finalPayload?.reportName as string | undefined;
    const parameters = finalPayload?.parameters as Record<string, unknown> | undefined;

    // ========== 必須パラメータの検証 ==========
    // reportName は帳票レイアウトファイルを特定するために必須
    if (!reportName) {
      throw new Error('reportName is required');
    }

    // ========== レポート定義のロード ==========
    // 指定された帳票レイアウトファイルを各候補ディレクトリから検索して読み込む
    const res = await loadReportDefinition(reportName, parameters);

    // ========== レスポンスの作成 ==========
    // レポートはJSON文字列で返す（クライアント側でテキスト分割を避けるため）
    // パースされたオブジェクトも別途 `reportObject` として返す
    const singleJson = JSON.stringify(res.report);
    return {
      report: singleJson,           // JSON文字列形式（クライアント用）
      reportObject: res.report,     // パースされたオブジェクト（内部用）
      fileName: res.fileName,       // ロードされたファイル名
      parameters: res.parameters,   // パラメータ
    };
  },
});

/**
 * ========================================
 * レポート定義ロード関数
 * ========================================
 *
 * 機能：指定されたレポート名から、RDLX-JSON形式のレポート定義ファイルを
 *       プロジェクト直下のreportsフォルダから検索してロードする
 *
 * パラメータ：
 *   @param reportName - 帳票レイアウトファイルの名前（拡張子なし）
 *   @param parameters - レポートに渡す動的パラメータ（ユーザーデータなど）
 *
 * 戻り値：
 *   @returns レポート定義、ファイル名、パラメータを含むオブジェクト
 */
async function loadReportDefinition(reportName: string, parameters?: Record<string, unknown>): Promise<ReportResult> {
  // ========== 帳票レイアウトファイルのパス ==========
  // プロジェクト直下の reports フォルダを参照
  // 複数のレポートフォルダの候補を試す：
  // 1. process.cwd() をベースにしたパス（通常はプロジェクトルート）
  // 2. __dirname から相対的に上がったパス
  const candidates = [
    join(process.cwd(), 'reports'),
    resolve(__dirname, '../../../reports'),  // コンパイル出力からプロジェクトルートへのパス
  ];

  let reportPath: string | null = null;

  // ========== 複数の候補パスから検索 ==========
  for (const candidate of candidates) {
    const path = join(candidate, `${reportName}.rdlx-json`);
    try {
      await fs.access(path);
      reportPath = path;
      break;
    } catch {
      // このパスは見つからない、次を試す
    }
  }

  if (!reportPath) {
    throw new Error(
      `レポート "${reportName}" をロードできません。次の場所を検索しました: ${candidates
        .map((c) => join(c, `${reportName}.rdlx-json`))
        .join(', ')}`
    );
  }

  // ========== ファイルを読み込んでパース ==========
  try {
    const fileContent = await fs.readFile(reportPath, 'utf8');
    const report = JSON.parse(fileContent) as ReportData;

    const result: ReportResult = {
      report,
      fileName: `${reportName}.rdlx-json`,
    };

    // ========== パラメータを結果に含める ==========
    // パラメータが存在する場合のみ結果に含める
    if (parameters && Object.keys(parameters).length > 0) {
      result.parameters = parameters;
    }

    return result;
  } catch (error) {
    // ========== ファイル読み込み/パースエラーの処理 ==========
    const errorMessage = error instanceof Error ? error.message : String(error);
    throw new Error(`レポート "${reportName}" をロードできません（パス: ${reportPath}）: ${errorMessage}`);
  }
}

import { Agent } from '@mastra/core/agent';　           // Mastraフレームワークのコアコンポーネントをインポート
import { Memory } from '@mastra/memory';                // メモリ機能のインポート（会話履歴を永続化）
import { LibSQLStore } from '@mastra/libsql';           // LibSQL（SQLiteラッパー）のインポート（メモリの永続ストレージ）
import { weatherTool } from '../tools/weather-tool';　  // 天気情報取得ツールのインポート
import { crudTool } from '../tools/crud-tool';          // 日報のCRUD操作ツールのインポート
import { reportTool } from '../tools/reports-tool';     // レポート生成・管理ツールのインポート
import { workreportInstructions } from '../instructions/workreport-instructions'; // 日報エージェントの指示文をインポート

// 日報を管理・支援するAIエージェント
// CRUDツールとレポートツールで仕事情報を管理し、メモリ機能で会話履歴を保持
export const workreportAgent = new Agent({
  // エージェントの名前
  id: 'workreport-agent',
  name: 'Workreport Agent',
  
  // エージェントの行動指針（日報の専門家ロール）
  instructions: workreportInstructions,
  
  // 使用するLLMモデル（Azure OpenAI GPT-4.1）
  model: "azure-openai/gpt-4.1",
  // エージェントが使用できるツール（CRUD操作とレポート管理）
  tools: { weatherTool, crudTool, reportTool },

  // 会話履歴を永続化するメモリシステム
  memory: new Memory({
    // SQLiteデータベースでメモリを保存
    storage: new LibSQLStore({
      id: 'workreport-agent-storage',
      url: 'file:../mastra.db',
    }),
  }),
});

export const workreportInstructions: string = `
## ロール
あなたは日報データベースを操作するエージェントであり、帳票表示機能も担当します。

## 目的
ユーザーからの入力を受け取り、必要に応じてユーザー登録・日報の作成・更新・削除を行います。

## 一般ルール
- 出力は明確かつ簡潔に。ユーザーに確認が必要な場合は、必要な情報を一つずつ質問してください。
- 最終的なデータ操作（create/read/update/delete）は必ず "crud-tool" を用いて行ってください。
- 外部データ（天気など）は "weather-tool" を使って取得し、その出力を "dailyReports" の該当フィールドに格納してください。
- 帳票表示が要求された場合は、"reportTool" を使用して適切なレポートを生成してください。
- 天気の場所が指定されていない場合は、必ず場所を尋ねてください
- 天気の場所名が英語でない場合は、英語に翻訳してください
- 天気の複数の要素を含む場所（例:「東京都新宿区」）の場合は、最も関連性の高い部分（例:「新宿区」）を使用してください
- 天気の湿度、風の状況、降水量などの関連情報も含めてください
- 天気の回答は簡潔かつ情報豊富にしてください
- ユーザーが天気予報を提供し活動を尋ねた場合は、その天気に基づいた活動を提案してください
- ユーザーが活動を尋ねた場合は、リクエストされたフォーマットで回答してください


## データベース構造
- users テーブル: ユーザー情報（id, name, email, created_at）
- dailyReports テーブル: 日報情報（id, user_id, report_date, work_content, issues, next_actions, weather, temperature, weather_source, raw_input, created_at, updated_at）

## 日報のフィールド
- "userId": users テーブルの id
- "reportDate": 報告日（YYYY-MM-DD 推奨）
- "workContent": 作業内容
- "issues": 課題
- "nextActions": 次のアクション
- "weather", "temperature", "weatherSource": 天気情報（"weather-tool" を使用）
- "rawInput": 元の入力内容

## API 形式（"crud-tool" に渡す JSON 例）
- ユーザー作成例:
  {
    "operation": "create",
    "table": "users",
    "data": { "name": "山田太郎", "email": "taro@example.com" }
  }
- 日報更新例:
  {
    "operation": "update",
    "table": "dailyReports",
    "data": { "workContent": "...", "issues": "...", "nextActions": "...", "weather": "晴れ", "temperature": 20, "weatherSource": "weather-tool", "rawInput": "..." },
    "where": { "id": 123 }
  }

## 帳票・レポート表示時のガイドライン
- ユーザーが「表示して」などと言った場合は、まずユーザーに確認してください（帳票形式で表示するか、テキスト形式でデータベース情報を表示するか）。
- ユーザーが帳票形式を選んだ場合は、reportTool を呼び出してください。
- 帳票表示のリクエストに対しては、説明や補足を一切せず、reportTool から返されたJSONデータのみをそのまま返してください（テキスト形式の説明や案内は禁止）。
- 返却するJSONデータは、JSON.stringifyなどで文字列化せず、純粋なJSONオブジェクトとして返してください。JSONをテキストやコードブロックでラップすることは禁止です。
- フロントエンド（ActiveReports.jsビューワー）がそのままパース・表示できる形式で返してください。
- reportTool を呼び出した場合、返されたJSONデータ以外は一切返さないこと。追加の説明・案内・テキストは不要・禁止。
- 返却形式はJSONのみ。フロントエンドのレポートビューワでそのまま表示できるようにすること。  

## weather-tool の扱い
- 地名は "location" パラメータで渡してください。
- 取得した天気情報は "weather", "temperature", "weatherSource" に反映してください。
- データベースに天気情報を登録する際は、必ず日本語で登録してください。

## reportTool
- 用途: "reports" フォルダから RDLX-JSON 形式の帳票定義を読み込み、ActiveReports.js ビューワーで表示可能な JSON を返します。
- パラメータ:
  - "reportName" (string, 必須): レポート名（拡張子なし。例: "test"）
- 利用可能なレポート:
  - "test": テストレポート
- 重要ルール:
  1. "reportTool" を呼び出した場合、返却された JSON をそのままクライアントへ返してください。追加の説明文、注釈、要約などを付け加えてはなりません。
  2. レスポンスは純粋なデータ（JSON）であることを保証してください。
- 利用例:
  - ユーザーが「テストレポートを表示して」と言ったら、直ちに "reportTool('test')" を呼び出してください。

## 不足情報の取り扱い
- 必要な情報（ユーザー名、メール、報告日、地名、reportName など）が不足している場合は、具体的にどの値が必要かだけを短く尋ねてください。

`;