name: hotel_milestone_tracker
description: 追蹤新飯店籌備期的工程進度、硬體驗收、物料採購與廠商合約節點，輸出進度報告並警示延誤風險。
triggers:
  - 籌備進度
  - 華邑酒店進度
  - 工程驗收
  - 採購追蹤
inputs:
  project_name:
    type: string
    description: 專案名稱（預設：華邑酒店籌備專案）。
    default: "華邑酒店籌備專案"
  update_notes:
    type: string
    description: 最新現場巡查紀錄、廠商反饋或進度更新。
    required: true

workflow:
  1. 里程碑分類：將更新歸類至四大模組（1. 現場硬體/工務驗收 2. 營運物料採購 3. 證照與法規驗收 4. 人員培訓與試營運）。
  2. 延誤與瓶頸識別：比對關鍵路徑（Critical Path），偵測是否會影響預定開幕/試營運日期。
  3. 行動建議產出：針對卡點提供 1-2 個替代方案或需向上層呈報裁決的具體事項。

output_template: |
  **🏨 【{{project_name}}】籌備進度看板**
  * **當前狀態評估：** [正常推進 / 輕度延遲 / 嚴重卡點]
  * **本期完成節點：** [列出已完成事項]

  **🚧 關鍵路徑追蹤表**
  | 籌備模組 | 當前關鍵任務 | 廠商/負責窗口 | 預定驗收日 | 狀態 | 風險評估 |
  | :--- | :--- | :--- | :--- | :--- | :--- |
  | 工務驗收 | [如：大廳地毯樣式確認] | [廠商/工務] | [YYYY-MM-DD] | 進行中 | [影響試營運/低] |

  **🚨 需高管裁決事項 (Action Required)**
  * [列出需鶴仁或總經理拍板的決策點]

# 定時 Skill：晨間營運摘要（morning-briefing-tracker）

- **觸發**：Cron 每日 08:00｜手動關鍵詞：`晨報、今日早報、晨會準備、早安簡報`
- **聚合**：未結案行動清單（今日到期/逾期）＋華邑籌備當週驗收節點＋昨日營運數據（Occ%/ADR/RevPAR）＋早會需高管確認事項
- **Cron 配置**：

```json
{
  "name": "Daily Hotel Morning Briefing",
  "schedule": "0 8 * * *",
  "timezone": "Asia/Taipei",
  "skill": "morning-briefing-tracker",
  "prompt": "請整合今日日期、當前所有未結案跨部門待辦及華邑酒店籌備最新進度，產出今日晨間營運摘要與重點提醒推播。"
}
```

- **輸出模板**：☀️ 晨間營運與籌備簡報 → 🔥 Top Priorities（P0 卡點 1-2 項）→ 🏨 華邑關鍵節點＋風險警示 → 📋 跨部門待追蹤清單（表格）→ 💡 早會提示

---

# 定時 Skill：晚間營運結算（evening-settlement-tracker）

- **觸發**：Cron 每日 22:30 或 23:00（夜審前／值班經理交班）｜手動關鍵詞：`晚報、今日營收、夜班交接、晚間結算`
- **聚合四維度**：當日核心營收（Occ%/ADR/RevPAR＋餐飲宴會）＋現場異常與重大客訴（免單/升等補償、設施故障）＋夜間交班巡檢（遲到 VIP、MOD 注意事項）＋明日營運預警（預估住房率、大團進出、人力佈署）
- **Cron 配置**：

```json
{
  "name": "Daily Hotel Evening Settlement",
  "schedule": "30 22 * * *",
  "timezone": "Asia/Taipei",
  "skill": "evening-settlement-tracker",
  "prompt": "請整合今日各部門回報之營運數據（住房率、ADR、RevPAR、餐飲營收）、客訴與現場異常紀錄，產出晚間營運結算與夜班交班簡報。"
}
```

- **輸出模板**：🌙 晚間營運結算與交班簡報 → 📊 當日核心營收指標（對比預算標註超標/落後）→ ⚠️ 現場異常與客訴 → 🛎️ 夜班交班要點（VIP/巡檢）→ 🔮 明日營運預警

> 晨間＋晚間形成完整閉環：早上主動準備決策視角，晚間結算當日績效與風險，搭配會議速記與籌備追蹤技能全面解放行政負擔。

---

/**
 * ChatGPT 项目对话导出（仅项目）
 * 只抓项目里的对话，间隔长，避免限流
 */
(async () => {
  console.log("🔑 获取 access token...");
  const sessionResp = await fetch("/api/auth/session");
  const { accessToken: token } = await sessionResp.json();
  if (!token) { console.error("❌ 无法获取 token"); return; }
  console.log("✅ Token 获取成功");

  const headers = { Authorization: `Bearer ${token}`, "Content-Type": "application/json" };
  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
  // 每次请求间隔 8~15 秒，非常保守
  const randomDelay = () => 8000 + Math.random() * 7000;

  async function apiGet(url, retries = 5) {
    for (let i = 0; i < retries; i++) {
      try {
        const resp = await fetch(url, { headers });
        if (resp.status === 429) {
          const wait = 30 + i * 15;  // 30s, 45s, 60s, 75s, 90s 递增等待
          console.warn(`⚠️ 限流，等 ${wait} 秒... (第${i+1}次)`);
          await sleep(wait * 1000);
          continue;
        }
        if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
        return await resp.json();
      } catch (e) {
        if (i === retries - 1) throw e;
        console.warn(`⚠️ 重试 ${i+1}/${retries}: ${e.message}`);
        await sleep(10000);
      }
    }
  }

  // 1. 获取项目列表
  console.log("\n📂 [1/3] 获取项目列表...");
  const sidebarData = await apiGet("/backend-api/gizmos/snorlax/sidebar");
  const projects = (sidebarData.items || []).map(item => ({
    id: item.gizmo?.id || item.id,
    name: item.gizmo?.display?.name || item.title || "未命名项目",
  }));
  console.log(`✅ 发现 ${projects.length} 个项目: ${projects.map(p => p.name).join(", ")}`);

  if (projects.length === 0) { console.log("没有项目，退出"); return; }

  // 2. 获取项目内对话列表
  console.log("\n📋 [2/3] 获取项目对话列表...");
  let projectConversations = [];

  for (const project of projects) {
    console.log(`  📂 项目「${project.name}」...`);
    let cursor = "0";

    while (cursor !== null && cursor !== undefined) {
      try {
        const data = await apiGet(`/backend-api/gizmos/${project.id}/conversations?cursor=${cursor}`);
        const items = data.items || [];
        if (items.length === 0) break;

        for (const item of items) {
          projectConversations.push({ ...item, _projectName: project.name });
        }

        cursor = data.cursor || null;
        await sleep(randomDelay());
      } catch (e) {
        console.warn(`  ⚠️ 项目「${project.name}」获取失败: ${e.message}`);
        break;
      }
    }
  }

  console.log(`✅ 项目对话共 ${projectConversations.length} 条`);

  // 3. 逐条下载完整对话
  console.log(`\n📥 [3/3] 下载对话内容（每条间隔 8~15 秒）...`);
  const allDetails = [];
  let success = 0, failed = 0;

  for (let i = 0; i < projectConversations.length; i++) {
    const conv = projectConversations[i];
    const title = conv.title || "Untitled";
    const project = conv._projectName;

    console.log(`  [${i+1}/${projectConversations.length}] ${title} (${project})`);

    try {
      const detail = await apiGet(`/backend-api/conversation/${conv.id}`);
      if (detail) {
        detail._source = `项目: ${project}`;
        allDetails.push(detail);
        success++;
        console.log(`    ✅ 成功`);
      } else {
        throw new Error("返回数据为空");
      }
    } catch (e) {
      console.warn(`    ❌ 失败: ${e.message}`);
      failed++;
    }

    if (i < projectConversations.length - 1) {
      const delay = randomDelay();
      console.log(`    ⏳ 等待 ${(delay/1000).toFixed(1)} 秒...`);
      await sleep(delay);
    }
  }

  // 生成文件
  function extractMessages(convData) {
    if (!convData || !convData.mapping) return [];
    const mapping = convData.mapping;
    let rootId = null;
    for (const [id, node] of Object.entries(mapping)) { if (!node.parent) { rootId = id; break; } }
    if (!rootId) return [];
    const messages = [], queue = [rootId];
    while (queue.length > 0) {
      const node = mapping[queue.shift()];
      if (!node) continue;
      const msg = node.message;
      if (msg && msg.content && msg.content.parts) {
        const role = msg.author?.role || "unknown";
        const text = msg.content.parts.filter(p => typeof p === "string").join("\n").trim();
        if (text && ["user","assistant","system","tool"].includes(role))
          messages.push({ role, content: text, model: msg.metadata?.model_slug || "" });
      }
      if (node.children?.length > 0) queue.push(node.children[0]);
    }
    return messages;
  }

  let allMd = `# ChatGPT 项目对话导出\n\n导出时间: ${new Date().toISOString()}\n共 ${allDetails.length} 条项目对话\n\n---\n\n`;
  for (const d of allDetails) {
    const title = d.title || "Untitled";
    const source = d._source || "";
    let ct = "unknown";
    try { if (d.create_time) ct = new Date(d.create_time * 1000).toISOString().slice(0,16).replace("T"," "); } catch(e) {}
    const msgs = extractMessages(d);
    allMd += `# ${title}\n\n**来源**: ${source} | **日期**: ${ct}\n\n`;
    for (const m of msgs) {
      const label = {user:"👤 User",assistant:"🤖 Assistant",system:"⚙️ System",tool:"🔧 Tool"}[m.role]||m.role;
      allMd += `\n## ${label}${m.model?` (${m.model})`:""}\n\n${m.content}\n\n`;
    }
    allMd += "\n---\n\n";
  }

  function dl(content, filename, type="application/json") {
    const a = document.createElement("a");
    a.href = URL.createObjectURL(new Blob([content], {type}));
    a.download = filename;
    document.body.appendChild(a); a.click(); document.body.removeChild(a);
  }

  dl(JSON.stringify(allDetails, null, 2), "chatgpt_project_conversations.json");
  await sleep(500);
  dl(allMd, "chatgpt_project_conversations.md", "text/markdown");

  console.log("\n" + "=".repeat(50));
  console.log(`🎉 项目对话导出完成! 成功: ${success}, 失败: ${failed}`);
  console.log("📁 已下载 2 个文件:");
  console.log("  - chatgpt_project_conversations.json");
  console.log("  - chatgpt_project_conversations.md");
  console.log("=".repeat(50));
})();

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
convert_chatgpt_to_obsidian.py
================================
Hermes 批次轉檔：ChatGPT 匯出 JSON → Obsidian 筆記
（配合 24kchengYe/chatgpt-exporter 產出的 chatgpt_all_conversations.json）

用法:
    python convert_chatgpt_to_obsidian.py <匯出資料夾> [--out <Obsidian輸出資料夾>]

輸入 (匯出資料夾內):
    chatgpt_all_conversations.json    — 全部對話（含 mapping 訊息、_source 專案標籤）
    chatgpt_conversations_index.json  — 索引（id/title/source/create_time）[可選]

輸出 (預設):
    <Obsidian>/Clippings/ChatGPT匯出_鶴仁/
        <專案名>/
            YYYYMMDD｜對話標題.md
        _00_匯出總覽.md                 — 各專案對話統計索引

特點:
    - 保留專案分組（_source: "项目: XX" / "常规对话"）
    - 每篇對話一筆筆記：YAML frontmatter + 逐輪訊息（👤/🤖）
    - 輸出總覽索引，方便 Obsidian 彙整
"""
import json, os, re, sys, io, argparse
from datetime import datetime

sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')

def safe_name(s, maxlen=60):
    s = re.sub(r'[\\/:*?"<>|\n\r\t]', ' ', s).strip()
    s = re.sub(r'\s+', ' ', s)
    return s[:maxlen].rstrip('.')

def extract_messages(conv):
    """從 mapping 提取 [role, content, model] 清單（與 chatgpt_export_all.js 相同邏輯）"""
    mapping = conv.get('mapping') or {}
    root_id = next((i for i, n in mapping.items() if not n.get('parent')), None)
    if not root_id:
        return []
    out, queue = [], [root_id]
    while queue:
        node = mapping.get(queue.pop(0))
        if not node:
            continue
        msg = node.get('message')
        if msg and msg.get('content', {}).get('parts'):
            role = (msg.get('author') or {}).get('role', 'unknown')
            parts = msg['content']['parts']
            text = '\n'.join(p for p in parts if isinstance(p, str)).strip()
            if text and role in ('user', 'assistant', 'system', 'tool'):
                out.append({'role': role, 'content': text,
                            'model': (msg.get('metadata') or {}).get('model_slug', '')})
        if node.get('children'):
            queue.append(node['children'][0])
    return out

def fmt_date(ts):
    """ChatGPT create_time 是 Unix epoch 秒"""
    if not ts:
        return ''
    try:
        return datetime.fromtimestamp(float(ts)).strftime('%Y-%m-%d %H:%M')
    except Exception:
        return ''

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument('src', help='ChatGPT 匯出資料夾（含 chatgpt_all_conversations.json）')
    ap.add_argument('--out', default=None,
                    help='Obsidian 輸出根資料夾（預設: <src> 上一層的 Obsidian 慣例路徑）')
    args = ap.parse_args()

    src_dir = args.src
    json_path = os.path.join(src_dir, 'chatgpt_all_conversations.json')
    if not os.path.exists(json_path):
        print(f'❌ 找不到 {json_path}')
        sys.exit(1)

    # 輸出資料夾：預設 G:/我的雲端硬碟/Obsidian/Clippings/ChatGPT匯出_鶴仁/
    if args.out:
        out_root = args.out
    else:
        vault = os.environ.get('OBSIDIAN_VAULT', r'G:/我的雲端硬碟/Obsidian')
        out_root = os.path.join(vault, 'Clippings', 'ChatGPT匯出_鶴仁')
    os.makedirs(out_root, exist_ok=True)

    convs = json.load(open(json_path, encoding='utf-8'))
    print(f'📄 讀取 {len(convs)} 篇對話')

    # 依 _source 分組：專案 → 對話清單
    groups = {}
    for c in convs:
        src = c.get('_source') or '常规对话'
        src = src.replace('项目: ', '').strip() if src.startswith('项目:') else src
        groups.setdefault(src, []).append(c)

    stats = {}
    total = 0
    for proj, items in sorted(groups.items()):
        proj_dir = os.path.join(out_root, safe_name(proj) or '未分類')
        os.makedirs(proj_dir, exist_ok=True)
        stats[proj] = len(items)
        for c in items:
            title = c.get('title') or 'Untitled'
            ts = fmt_date(c.get('create_time'))
            date_prefix = ts[:10].replace('-', '') if ts else '日期待確認'
            fname = f'{date_prefix}｜{safe_name(title, 45)}.md'
            fpath = os.path.join(proj_dir, fname)
            msgs = extract_messages(c)
            label = {'user': '👤 User', 'assistant': '🤖 Assistant',
                     'system': '⚙️ System', 'tool': '🔧 Tool'}
            body = '\n\n'.join(
                f'## {label.get(m["role"], m["role"])}' +
                (f' ({m["model"]})' if m['model'] else '') + '\n\n' + m['content']
                for m in msgs)
            note = (f'---\ncreated: {ts or ""}\nsource: ChatGPT 匯出\nproject: {proj}\n'
                    f'tags: [ChatGPT匯出, 鶴仁]\n---\n\n'
                    f'# {title}\n\n> [!info] 對話資訊\n> - **專案**: {proj}\n'
                    f'> - **日期**: {ts or "待確認"}\n> - **訊息數**: {len(msgs)}\n\n{body}\n')
            with open(fpath, 'w', encoding='utf-8-sig') as f:
                f.write(note)
            total += 1
        print(f'  ✅ {proj}: {len(items)} 篇 → {proj_dir}')

    # 總覽索引
    overview = ['---\ncreated: 2026-08-18\nsource: ChatGPT 匯出\n'
                'tags: [ChatGPT匯出, 鶴仁, 索引]\n---\n',
                '# ChatGPT 對話匯出總覽（鶴仁）', '']
    overview.append('| 專案 | 對話數 |')
    overview.append('|---|---|')
    for proj, n in sorted(stats.items()):
        overview.append(f'| [[{safe_name(proj) or "未分類"}]] | {n} |')
    overview.append(f'\n**合計：{total} 篇對話**')
    with open(os.path.join(out_root, '_00_匯出總覽.md'), 'w', encoding='utf-8-sig') as f:
        f.write('\n'.join(overview) + '\n')

    print(f'\n🎉 完成！共 {total} 篇筆記 → {out_root}')

if __name__ == '__main__':
    main()

"""
Merge regular and project ChatGPT exports into a single file.

Usage:
  python merge_exports.py --regular all.json --projects projects.json --output merged/

Or simply:
  python merge_exports.py  (uses default paths in current directory)
"""

import json
import os
import sys
import argparse
from datetime import datetime


def extract_messages(conv_data):
    """Extract ordered messages from conversation mapping tree."""
    if not conv_data or 'mapping' not in conv_data:
        return []
    mapping = conv_data['mapping']
    root_id = None
    for nid, node in mapping.items():
        if node.get('parent') is None:
            root_id = nid
            break
    if not root_id:
        return []
    messages = []
    queue = [root_id]
    while queue:
        node_id = queue.pop(0)
        node = mapping.get(node_id, {})
        msg = node.get('message')
        if msg and msg.get('content') and msg['content'].get('parts'):
            role = msg.get('author', {}).get('role', 'unknown')
            parts = [p for p in msg['content']['parts'] if isinstance(p, str)]
            text = '\n'.join(parts).strip()
            if text and role in ('user', 'assistant', 'system', 'tool'):
                model = msg.get('metadata', {}).get('model_slug', '')
                messages.append({'role': role, 'content': text, 'model': model})
        children = node.get('children', [])
        if children:
            queue.append(children[0])
    return messages


def main():
    parser = argparse.ArgumentParser(description='Merge ChatGPT exports')
    parser.add_argument('--regular', default='chatgpt_all_conversations.json',
                        help='Regular conversations JSON file')
    parser.add_argument('--projects', default='chatgpt_project_conversations.json',
                        help='Project conversations JSON file')
    parser.add_argument('--output', default='merged',
                        help='Output directory')
    args = parser.parse_args()

    # Load files
    all_conv = []
    if os.path.exists(args.regular):
        all_conv = json.load(open(args.regular, encoding='utf-8'))
        print(f"Regular conversations: {len(all_conv)}")
    else:
        print(f"Warning: {args.regular} not found, skipping")

    proj_conv = []
    if os.path.exists(args.projects):
        proj_conv = json.load(open(args.projects, encoding='utf-8'))
        print(f"Project conversations: {len(proj_conv)}")
    else:
        print(f"Warning: {args.projects} not found, skipping")

    # Deduplicate and merge
    existing_ids = set()
    for d in all_conv:
        cid = d.get('conversation_id') or d.get('id', '')
        existing_ids.add(cid)

    added = 0
    for d in proj_conv:
        cid = d.get('conversation_id') or d.get('id', '')
        if cid not in existing_ids:
            all_conv.append(d)
            existing_ids.add(cid)
            added += 1

    # Sort by create_time
    all_conv.sort(key=lambda x: x.get('create_time') or 0)
    print(f"Merged total: {len(all_conv)} (added {added} from projects)")

    # Create output directory
    os.makedirs(args.output, exist_ok=True)

    # Save merged JSON
    json_path = os.path.join(args.output, 'chatgpt_merged_all.json')
    with open(json_path, 'w', encoding='utf-8') as f:
        json.dump(all_conv, f, ensure_ascii=False, indent=2)
    print(f"Saved: {json_path}")

    # Save merged Markdown (using plain text separators to avoid conflicts)
    md_path = os.path.join(args.output, 'chatgpt_merged_all.md')
    lines = []
    lines.append(f'<!-- ChatGPT Full Export -->')
    lines.append(f'<!-- Exported: {datetime.now().strftime("%Y-%m-%d %H:%M")} -->')
    lines.append(f'<!-- Total: {len(all_conv)} conversations -->\n')

    for idx, d in enumerate(all_conv):
        title = d.get('title', 'Untitled')
        source = d.get('_source', 'Regular')
        ct = 'unknown'
        try:
            if d.get('create_time'):
                ct = datetime.fromtimestamp(d['create_time']).strftime('%Y-%m-%d %H:%M')
        except:
            pass

        lines.append(f'{"=" * 60}')
        lines.append(f'Conversation {idx+1}/{len(all_conv)}: {title}')
        lines.append(f'Source: {source} | Date: {ct}')
        lines.append(f'{"=" * 60}\n')

        msgs = extract_messages(d)
        for m in msgs:
            role_label = {'user': 'User', 'assistant': 'Assistant',
                          'system': 'System', 'tool': 'Tool'}.get(m['role'], m['role'])
            model_str = f" ({m['model']})" if m.get('model') else ''
            lines.append(f'--- {role_label}{model_str} ---\n')
            lines.append(m['content'])
            lines.append('')
        lines.append('')

    with open(md_path, 'w', encoding='utf-8') as f:
        f.write('\n'.join(lines))
    print(f"Saved: {md_path}")


if __name__ == '__main__':
    main()

# ChatGPT 對話匯出教學（給鶴仁，現場實作）

> 目的：把鶴仁現有 ChatGPT 專案對話完整導出，轉存進 Obsidian 第二大腦。
> 方案：② 瀏覽器一鍵匯出 ＋ ③ Hermes 批次轉檔（最佳解，保留專案分組）

## 三步驟流程

### ① 鶴仁匯出（1 分鐘，在他的瀏覽器）
1. 開啟 https://chatgpt.com 並登入
2. 按 `F12` → **Console** 分頁
3. 複製 `chatgpt_export_all.js` 全部內容 → 貼進 Console → Enter
4. 等待跑完（進度列顯示 ✅），會自動下載 3 個檔：
   - `chatgpt_all_conversations.json`（完整對話，含專案）
   - `chatgpt_conversations_index.json`（索引）
   - `chatgpt_all_conversations.md`（人讀版）
5. **跑完前不要重新整理頁面！**

> ⚠️ 若為免費帳號遇到限流：改用 `chatgpt_export_projects_only.js`（保守模式）分次跑，再用 `merge_exports.py` 合併。

### ② 放進共享資料夾
- 把下載的 JSON 檔放進 Google 雲端硬碟共享資料夾（告訴 Hermes 路徑即可）

### ③ Hermes 批次轉檔（自動）
- Hermes 執行 `convert_chatgpt_to_obsidian.py`：
  - 依**專案分組**建立資料夾（華邑籌備／數據分析／…）
  - 每篇對話 → 一筆 Obsidian 筆記（`YYYYMMDD｜主題.md`）
  - 自動產生 `_00_匯出總覽.md` 索引
- 輸出：`Obsidian/Clippings/ChatGPT匯出_鶴仁/`

## 檔案清單（本工具包 `ChatGPT匯出工具/`）

| 檔名 | 用途 |
|---|---|
| `chatgpt_export_all.js` | 一鍵匯出全部（一般＋專案），1.5–4s 隨機延遲 |
| `chatgpt_export_projects_only.js` | 僅匯出專案對話，8–15s 保守模式（免費帳號用） |
| `merge_exports.py` | 多次匯出合併成單一檔 |
| `convert_chatgpt_to_obsidian.py` | Hermes 批次轉檔核心（JSON → Obsidian 筆記） |

## 注意事項
- 匯出在鶴仁自己的瀏覽器 session 內執行（使用他自己的登入 token），不需 API Key
- 官方匯出（Settings → Data controls → Export）可並行申請當全量備份，但**不含專案分組**（最多 7 天）
- 工具來源：GitHub `24kchengYe/chatgpt-exporter`（MIT，開源）