claudeに予定とタスクを管理させてみた

/**
 * Google Tasks 同期ブリッジ(Claude用)
 *
 * このスクリプトがGoogle Tasksに対して行う操作は次の3つだけです。
 *   1. 読み取り   … タスク一覧を tasks_snapshot.json とシート「Tasks」に書き出す
 *   2. 追加       … op: "ADD"
 *   3. メモ追記   … op: "APPEND_NOTE"(既存メモの末尾に足すだけ。既存部分は書き換えない)
 * 完了・削除・移動・タイトル/期日/状態の変更を行うコードは含まれていません
 * (使うAPIは Tasklists.list / Tasks.list / Tasks.get / Tasks.insert / Tasks.patch(notesのみ) の5つだけ)。
 *
 * Claudeとのやりとり:
 *   Claude は My Drive/claude/google-tasks-sync/tasks-inbox に JSON ファイルを置くだけです。
 *   このスクリプトが1分ごとに inbox を確認して処理し、処理済みファイルは
 *   tasks-processed に移動します(削除はしません)。
 *
 * 初回だけ: 左の「サービス」+ → Google Tasks API を追加 → 関数 setup を実行して承認。
 */

const CONFIG = {
  HOME_PATH: 'claude/google-tasks-sync', // このスプレッドシートを置く場所(My Drive から)
  INBOX_FOLDER: 'tasks-inbox',
  PROCESSED_FOLDER: 'tasks-processed',
  SNAPSHOT_FILE: 'tasks_snapshot.json', // 機械向け(JSON)
  SNAPSHOT_DOC: 'tasks_snapshot',       // Claudeが Drive 連携で全文を読む用(Googleドキュメント)
  SHEET_TASKS: 'Tasks',
  SHEET_LOG: 'Log',
  SHEET_STATUS: 'Status',
  BASELINE_SYNC_MIN: 10,      // 依頼がなくても最低この間隔で同期する
  MAX_BACKOFF_MIN: 60,        // 失敗が続いたときの再試行間隔の上限
  COMPLETED_LOOKBACK_DAYS: 7, // 完了済みは直近7日分だけ書き出す
  MAX_REQUESTS_PER_RUN: 20,
  MAX_TEXT_CHARS: 2000,
  MAX_NOTES_CHARS: 8000,      // Tasks APIのメモ上限(8192字)より手前で止める
  MAX_TITLE_CHARS: 300,
  KEEP_RESULTS: 100,          // スナップショットに載せる直近の処理結果の件数
  TZ: 'Asia/Tokyo',
};
const ALLOWED_OPS = ['SYNC', 'ADD', 'APPEND_NOTE'];
const LOG_HEADER = ['処理日時', 'request_id', 'op', '結果', 'list_id', 'task_id', 'タイトル', 'メモ', '依頼元', 'ファイル名'];
const TASK_HEADER = ['リスト', 'list_id', 'task_id', '親task_id', 'タイトル', '状態', '期日', 'メモ', '更新日時', '完了日時', 'リンク'];

// ───────────── セットアップ ─────────────

function setup() {
  const ss = SpreadsheetApp.getActiveSpreadsheet();
  const parent = DriveApp.getFileById(ss.getId()).getParents().next();
  assertHome_(parent);
  const props = PropertiesService.getScriptProperties();
  props.setProperty('INBOX_ID', getOrCreateFolder_(parent, CONFIG.INBOX_FOLDER).getId());
  props.setProperty('PROCESSED_ID', getOrCreateFolder_(parent, CONFIG.PROCESSED_FOLDER).getId());
  props.setProperty('SNAPSHOT_ID', getOrCreateFile_(parent, CONFIG.SNAPSHOT_FILE).getId());
  props.setProperty('SNAPSHOT_DOC_ID', getOrCreateDoc_(parent, CONFIG.SNAPSHOT_DOC).getId());
  ['FAIL_COUNT', 'NEXT_RETRY_MS'].forEach(function (k) { props.deleteProperty(k); });

  const log = ss.getSheetByName(CONFIG.SHEET_LOG) || ss.insertSheet(CONFIG.SHEET_LOG);
  if (log.getLastRow() === 0) log.appendRow(LOG_HEADER);

  // tick のトリガーだけを作り直す(他のトリガーには触れない)
  ScriptApp.getProjectTriggers().forEach(function (t) {
    if (t.getHandlerFunction() === 'tick') ScriptApp.deleteTrigger(t);
  });
  ScriptApp.newTrigger('tick').timeBased().everyMinutes(1).create();

  run_(true);
  Logger.log('セットアップ完了。1分ごとに inbox を確認し、10分ごとに同期します。');
}

/** 手動ですぐ同期したいとき用 */
function syncNow() { run_(true); }

/** 1分ごとのトリガー */
function tick() { run_(false); }

// ───────────── メイン ─────────────

function run_(force) {
  const lock = LockService.getScriptLock();
  if (!lock.tryLock(10000)) return; // 前の実行がまだ動いていれば今回は何もしない
  const props = PropertiesService.getScriptProperties();
  try {
    // 失敗が続いている間は、次の再試行の時刻まで待つ
    if (!force && Date.now() < Number(props.getProperty('NEXT_RETRY_MS') || 0)) return;

    const inbox = DriveApp.getFolderById(props.getProperty('INBOX_ID'));
    const files = listInbox_(inbox);
    const lastSync = Number(props.getProperty('LAST_SYNC_MS') || 0);
    const stale = Date.now() - lastSync >= CONFIG.BASELINE_SYNC_MIN * 60000;
    if (!force && files.length === 0 && !stale) return; // 何もすることがない

    const ss = SpreadsheetApp.getActiveSpreadsheet();
    const processed = DriveApp.getFolderById(props.getProperty('PROCESSED_ID'));
    const logged = loggedIds_(ss);
    const cache = { tasks: null };

    files.slice(0, CONFIG.MAX_REQUESTS_PER_RUN).forEach(function (f) {
      const r = processFile_(f, logged, cache);
      if (r.status !== 'IGNORED') {
        appendLog_(ss, r);
        if (r.request_id) logged[r.request_id] = true;
      }
      f.moveTo(processed); // 削除はせず処理済みフォルダへ
    });

    const openCount = syncSnapshot_(ss, props);
    ['LAST_ERROR', 'FAIL_COUNT', 'NEXT_RETRY_MS'].forEach(function (k) { props.deleteProperty(k); });
    writeStatus_(ss, props, openCount);
  } catch (e) {
    const fails = Number(props.getProperty('FAIL_COUNT') || 0) + 1;
    const waitMin = Math.min(Math.pow(2, fails - 1), CONFIG.MAX_BACKOFF_MIN);
    props.setProperty('FAIL_COUNT', String(fails));
    props.setProperty('NEXT_RETRY_MS', String(Date.now() + waitMin * 60000));
    const msg = fmt_(new Date()) + ' ' + (e && e.message ? e.message : e);
    props.setProperty('LAST_ERROR', msg);
    console.error(msg);
    try { writeStatus_(SpreadsheetApp.getActiveSpreadsheet(), props, null); } catch (ignore) {}
    // スナップショットは上書きしない(前回の内容を残す)
  } finally {
    lock.releaseLock();
  }
}

// ───────────── 依頼の処理 ─────────────

function processFile_(f, logged, cache) {
  const base = { file: f.getName(), request_id: '', op: '', list_id: '', task_id: '', title: '', requested_by: '' };
  let req;
  try {
    const mime = f.getMimeType();
    if (mime !== 'application/json' && mime !== 'text/plain') {
      return Object.assign(base, rej_('JSONファイルではありません: ' + mime));
    }
    req = JSON.parse(f.getBlob().getDataAsString('UTF-8'));
  } catch (e) {
    return Object.assign(base, rej_('JSONとして読めません'));
  }
  if (!req || typeof req !== 'object') return Object.assign(base, rej_('JSONオブジェクトではありません'));

  const id = cleanId_(req.request_id);
  const op = clean_(req.op).toUpperCase();
  base.request_id = id;
  base.op = op;
  base.requested_by = clean_(req.requested_by);
  base.title = clean_(req.title);

  if (!/^[A-Za-z0-9_.:\-]{1,80}$/.test(id)) return Object.assign(base, rej_('request_id が不正です'));
  if (ALLOWED_OPS.indexOf(op) < 0) return Object.assign(base, rej_('許可されていない操作です: ' + op));
  if (logged[id]) return Object.assign(base, { status: 'IGNORED' });

  const marker = '[claude-req:' + id + ']';
  try {
    let r;
    if (op === 'SYNC') r = { status: 'DONE', note: '同期依頼' };
    else if (op === 'ADD') r = addTask_(req, marker, cache);
    else r = appendNote_(req, marker);
    return Object.assign(base, r);
  } catch (e) {
    return Object.assign(base, { status: 'ERROR', note: String(e && e.message ? e.message : e).slice(0, 300) });
  }
}

/** op: ADD … タスクを1件追加する */
function addTask_(req, marker, cache) {
  const title = clean_(req.title);
  if (!title) return rej_('title が空です');
  if (title.length > CONFIG.MAX_TITLE_CHARS) return rej_('title が長すぎます');
  const due = normalizeDue_(req.due);
  if (due === null) return rej_('due は YYYY-MM-DD で指定してください');
  const text = clean_(req.text);
  if (text.length > CONFIG.MAX_TEXT_CHARS) return rej_('text が長すぎます');
  const listId = cleanId_(req.list_id) || '@default';

  if (!cache.tasks) cache.tasks = fetchTasks_().tasks;

  // 前回の実行が途中で止まっていた場合の二重作成防止
  const again = cache.tasks.filter(function (t) { return (t.notes || '').indexOf(marker) >= 0; })[0];
  if (again) return { status: 'DONE', list_id: again.list_id, task_id: again.task_id, note: '作成済み(再試行)' };

  // 同じタイトルの未完了タスクがあれば追加しない
  const key = normTitle_(title);
  const dup = cache.tasks.filter(function (t) {
    return t.status !== 'completed' && normTitle_(t.title) === key;
  })[0];
  if (dup) {
    return { status: 'DUPLICATE', list_id: dup.list_id, task_id: dup.task_id,
             note: '同じタイトルの未完了タスクがあるため追加していません' };
  }

  const notes = (text ? text + '\n\n' : '') + '(Claudeが追加 ' + fmt_(new Date()) + ') ' + marker;
  const body = { title: title, notes: notes };
  if (due) body.due = due + 'T00:00:00.000Z';
  const created = Tasks.Tasks.insert(body, listId);
  cache.tasks.push({ list_id: listId, task_id: created.id, title: title, status: 'needsAction', notes: notes });
  return { status: 'DONE', list_id: listId, task_id: created.id, note: '追加しました' };
}

/** op: APPEND_NOTE … 既存タスクのメモ末尾に追記する(既存の文字は変更しない) */
function appendNote_(req, marker) {
  const listId = cleanId_(req.list_id);
  const taskId = cleanId_(req.task_id);
  const text = clean_(req.text);
  if (!listId || !taskId) return rej_('list_id と task_id が必要です');
  if (!text) return rej_('text が空です');
  if (text.length > CONFIG.MAX_TEXT_CHARS) return rej_('text が長すぎます');

  let cur;
  try {
    cur = Tasks.Tasks.get(listId, taskId); // 追記の直前に最新のメモを取得する
  } catch (e) {
    return rej_('タスクが見つかりません');
  }
  const ids = { list_id: listId, task_id: taskId };
  if (cur.deleted) return Object.assign(ids, rej_('削除済みのタスクです'));
  if (cur.status === 'completed') return Object.assign(ids, { status: 'SKIPPED', note: '完了済みのタスクには追記しません' });

  const old = cur.notes || '';
  if (old.indexOf(marker) >= 0) return Object.assign(ids, { status: 'DONE', note: '追記済み(再試行)' });

  const add = '(Claude追記 ' + fmt_(new Date()) + ') ' + text + ' ' + marker;
  const next = old ? old + '\n\n' + add : add;
  if (next.length > CONFIG.MAX_NOTES_CHARS) return Object.assign(ids, rej_('メモが上限を超えるため追記しません'));

  // notes だけを送る。タイトル・期日・状態は送らないので変わらない
  Tasks.Tasks.patch({ notes: next }, listId, taskId);
  return Object.assign(ids, { status: 'DONE', note: '追記しました' });
}

// ───────────── 読み取りと書き出し ─────────────

function fetchTasks_() {
  const lists = pageAll_(function (tok) {
    const p = { maxResults: 100 };
    if (tok) p.pageToken = tok;
    return Tasks.Tasklists.list(p);
  });
  const minDone = new Date(Date.now() - CONFIG.COMPLETED_LOOKBACK_DAYS * 864e5).toISOString();
  const rows = [];
  lists.forEach(function (l) {
    const open = pageAll_(function (tok) {
      const p = { maxResults: 100, showCompleted: false };
      if (tok) p.pageToken = tok;
      return Tasks.Tasks.list(l.id, p);
    });
    const done = pageAll_(function (tok) {
      const p = { maxResults: 100, showCompleted: true, showHidden: true, completedMin: minDone };
      if (tok) p.pageToken = tok;
      return Tasks.Tasks.list(l.id, p);
    }).filter(function (t) { return t.status === 'completed'; });
    open.concat(done).forEach(function (t) {
      rows.push({
        list_title: l.title || '',
        list_id: l.id,
        task_id: t.id,
        parent_id: t.parent || '',
        title: t.title || '',
        status: t.status || '',
        due: t.due ? String(t.due).slice(0, 10) : '',
        notes: t.notes || '',
        updated_jst: t.updated ? fmt_(new Date(t.updated)) : '',
        completed_jst: t.completed ? fmt_(new Date(t.completed)) : '',
        link: t.webViewLink || '',
      });
    });
  });
  rows.sort(function (a, b) {
    if (a.status !== b.status) return a.status === 'completed' ? 1 : -1;
    const da = a.due || '9999-99-99', db = b.due || '9999-99-99';
    if (da !== db) return da < db ? -1 : 1;
    return a.list_title < b.list_title ? -1 : a.list_title > b.list_title ? 1 : 0;
  });
  return { lists: lists.map(function (l) { return { id: l.id, title: l.title }; }), tasks: rows };
}

/** スナップショット(JSON・ドキュメント・シート)を書き直し、未完了タスクの数を返す */
function syncSnapshot_(ss, props) {
  const started = Date.now();
  const data = fetchTasks_();
  const results = readLog_(ss, CONFIG.KEEP_RESULTS);
  const snap = {
    generated_at_epoch_ms: started,
    generated_at_jst: fmt_(new Date(started)),
    note: 'Google Tasks の読み取り専用コピー。このファイルを編集しても Tasks には反映されない。',
    served_request_ids: results.map(function (r) { return r.request_id; }).filter(String),
    recent_results: results,
    lists: data.lists,
    tasks: data.tasks,
  };
  DriveApp.getFileById(props.getProperty('SNAPSHOT_ID')).setContent(JSON.stringify(snap));

  // Googleドキュメント版: 1行1件のJSONで書く(Drive連携の読み取りで全文が返る)
  const lines = [
    'generated_at_epoch_ms: ' + snap.generated_at_epoch_ms,
    'generated_at_jst: ' + snap.generated_at_jst,
    'served_request_ids: ' + snap.served_request_ids.join(' '),
    'note: ' + snap.note,
    '[TASKS] 未完了 → 直近' + CONFIG.COMPLETED_LOOKBACK_DAYS + '日の完了済み の順。1行1件',
  ].concat(data.tasks.map(function (t) { return JSON.stringify(t); }))
   .concat(['[RECENT_RESULTS] Claudeからの依頼の処理結果(古い順)'])
   .concat(results.map(function (r) { return JSON.stringify(r); }))
   .concat(['[END]']);
  DocumentApp.openById(props.getProperty('SNAPSHOT_DOC_ID')).getBody().setText(lines.join('\n'));

  const sh = ss.getSheetByName(CONFIG.SHEET_TASKS) || ss.insertSheet(CONFIG.SHEET_TASKS);
  sh.clearContents();
  const values = [TASK_HEADER].concat(data.tasks.map(function (t) {
    return [t.list_title, t.list_id, t.task_id, t.parent_id, t.title, t.status, t.due,
            t.notes, t.updated_jst, t.completed_jst, t.link].map(safe_);
  }));
  sh.getRange(1, 1, values.length, TASK_HEADER.length).setValues(values);

  props.setProperty('LAST_SYNC_MS', String(started));
  return data.tasks.filter(function (t) { return t.status !== 'completed'; }).length;
}

function writeStatus_(ss, props, openCount) {
  const sh = ss.getSheetByName(CONFIG.SHEET_STATUS) || ss.insertSheet(CONFIG.SHEET_STATUS);
  const last = Number(props.getProperty('LAST_SYNC_MS') || 0);
  const next = Number(props.getProperty('NEXT_RETRY_MS') || 0);
  sh.getRange(1, 1, 6, 2).setValues([
    ['最終同期 (JST)', last ? fmt_(new Date(last)) : '未同期'],
    ['最終エラー', safe_(props.getProperty('LAST_ERROR') || '')],
    ['タスク数 (未完了)', openCount === null ? sh.getRange(3, 2).getValue() : openCount],
    ['連続失敗回数', Number(props.getProperty('FAIL_COUNT') || 0)],
    ['次の再試行 (JST)', next ? fmt_(new Date(next)) : ''],
    ['説明', 'このファイルと tasks_snapshot は Apps Script が自動で上書きする読み取り用のコピーです。ここを編集しても Google Tasks には反映されません。'],
  ]);
}

// ───────────── ログ ─────────────

function appendLog_(ss, r) {
  const sh = ss.getSheetByName(CONFIG.SHEET_LOG);
  sh.appendRow([fmt_(new Date()), r.request_id, r.op, r.status, r.list_id || '', r.task_id || '',
                r.title || '', r.note || '', r.requested_by || '', r.file || ''].map(safe_));
}

function loggedIds_(ss) {
  const sh = ss.getSheetByName(CONFIG.SHEET_LOG);
  const n = sh.getLastRow();
  const out = {};
  if (n < 2) return out;
  sh.getRange(2, 2, n - 1, 1).getValues().forEach(function (v) { if (v[0]) out[String(v[0])] = true; });
  return out;
}

function readLog_(ss, limit) {
  const sh = ss.getSheetByName(CONFIG.SHEET_LOG);
  const n = sh.getLastRow();
  if (n < 2) return [];
  const start = Math.max(2, n - limit + 1);
  return sh.getRange(start, 1, n - start + 1, LOG_HEADER.length).getValues().map(function (v) {
    return { processed_at_jst: String(v[0]), request_id: String(v[1]), op: String(v[2]), status: String(v[3]),
             list_id: String(v[4]), task_id: String(v[5]), title: String(v[6]), note: String(v[7]) };
  });
}

// ───────────── 補助関数 ─────────────

/** スプレッドシートが My Drive/<HOME_PATH> にあることを確かめる(別の場所にファイルを作らないため) */
function assertHome_(folder) {
  const rootId = DriveApp.getRootFolder().getId();
  const names = [];
  let f = folder;
  while (f.getId() !== rootId) {
    names.unshift(f.getName());
    const ps = f.getParents();
    if (!ps.hasNext()) break;
    f = ps.next();
  }
  if (f.getId() !== rootId || names.join('/') !== CONFIG.HOME_PATH) {
    throw new Error('このスプレッドシートを My Drive/' + CONFIG.HOME_PATH + ' に置いてください');
  }
}

function listInbox_(folder) {
  const out = [];
  const it = folder.getFiles();
  while (it.hasNext()) out.push(it.next());
  out.sort(function (a, b) { return a.getDateCreated() - b.getDateCreated(); });
  return out;
}

function pageAll_(fn) {
  const out = [];
  let tok = null;
  do {
    const res = fn(tok);
    (res.items || []).forEach(function (x) { out.push(x); });
    tok = res.nextPageToken || null;
  } while (tok);
  return out;
}

function getOrCreateFolder_(parent, name) {
  const it = parent.getFoldersByName(name);
  return it.hasNext() ? it.next() : parent.createFolder(name);
}

function getOrCreateFile_(parent, name) {
  const it = parent.getFilesByName(name);
  return it.hasNext() ? it.next() : parent.createFile(name, '{}', 'application/json');
}

function getOrCreateDoc_(parent, name) {
  const it = parent.getFilesByName(name);
  while (it.hasNext()) {
    const f = it.next();
    if (f.getMimeType() === MimeType.GOOGLE_DOCS) return f;
  }
  const doc = DocumentApp.create(name);
  const f = DriveApp.getFileById(doc.getId());
  f.moveTo(parent);
  return f;
}

/** IDにはバックスラッシュが含まれないので除去する(Drive連携の読み取りで _ が \_ になるため) */
function cleanId_(v) { return clean_(v).replace(/\\/g, ''); }

function rej_(msg) { return { status: 'REJECTED', note: msg }; }

function clean_(v) { return v === null || v === undefined ? '' : String(v).trim(); }

function normalizeDue_(v) {
  const s = clean_(v);
  if (!s) return '';
  if (!/^\d{4}-\d{2}-\d{2}$/.test(s)) return null;
  const d = new Date(s + 'T00:00:00Z');
  return isNaN(d.getTime()) || d.toISOString().slice(0, 10) !== s ? null : s;
}

function normTitle_(s) {
  return String(s || '').normalize('NFKC').toLowerCase().replace(/\s+/g, '');
}

function fmt_(d) { return Utilities.formatDate(d, CONFIG.TZ, 'yyyy-MM-dd HH:mm:ss'); }

/** シートに書くとき、= + - @ で始まる文字列が数式として解釈されないようにする */
function safe_(v) {
  if (typeof v !== 'string') return v;
  return /^[=+\-@]/.test(v) ? "'" + v : v;
}