@adonis0123/weekly-report 1.0.6

package/src/storage.py

@@ -0,0 +1,491 @@
+"""存储管理模块
+
+管理周报的存储和检索。
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class ReportEntry:
+    summary: str
+    details: List[str]
+
+
+def _parse_report_markdown(content: str) -> tuple[list[str], dict[str, list[ReportEntry]]]:
+    preamble: list[str] = []
+    sections: dict[str, list[ReportEntry]] = {}
+
+    current_section: Optional[str] = None
+    current_entry: Optional[ReportEntry] = None
+    started_sections = False
+
+    for raw_line in content.splitlines():
+        line = raw_line.rstrip("\n")
+        if not line.strip():
+            if not started_sections:
+                preamble.append(line)
+            continue
+
+        if line.startswith("#"):
+            if not started_sections:
+                preamble.append(line)
+                continue
+
+        if not line.startswith(" "):
+            started_sections = True
+            current_section = line.strip()
+            sections.setdefault(current_section, [])
+            current_entry = None
+            continue
+
+        if line.startswith("  - "):
+            if current_section is None:
+                started_sections = True
+                current_section = "其他"
+                sections.setdefault(current_section, [])
+
+            current_entry = ReportEntry(summary=line[4:].strip(), details=[])
+            sections[current_section].append(current_entry)
+            continue
+
+        if line.startswith("    - ") and current_entry is not None:
+            current_entry.details.append(line[6:].strip())
+            continue
+
+        # 兼容意外格式：把未知缩进行作为当前 entry 的 detail
+        if current_entry is not None and line.startswith(" "):
+            current_entry.details.append(line.strip())
+
+    return preamble, sections
+
+
+def _dedupe_preserve_order(items: List[str]) -> List[str]:
+    seen: set[str] = set()
+    result: List[str] = []
+    for item in items:
+        key = item.strip()
+        if not key or key in seen:
+            continue
+        seen.add(key)
+        result.append(item.strip())
+    return result
+
+
+def _merge_sections(
+    existing: dict[str, list[ReportEntry]],
+    new: dict[str, list[ReportEntry]],
+) -> dict[str, list[ReportEntry]]:
+    merged: dict[str, list[ReportEntry]] = {}
+
+    # 保留已有 section 的顺序
+    for section, entries in existing.items():
+        merged[section] = [ReportEntry(e.summary, list(e.details)) for e in entries]
+
+    # 合并新内容
+    for section, entries in new.items():
+        if section not in merged:
+            merged[section] = [ReportEntry(e.summary, list(e.details)) for e in entries]
+            continue
+
+        by_summary: dict[str, ReportEntry] = {e.summary: e for e in merged[section]}
+        for entry in entries:
+            if entry.summary in by_summary:
+                target = by_summary[entry.summary]
+                target.details = _dedupe_preserve_order(target.details + entry.details)
+            else:
+                merged[section].append(ReportEntry(entry.summary, list(entry.details)))
+                by_summary[entry.summary] = merged[section][-1]
+
+    # 统一去重
+    for section, entries in merged.items():
+        for entry in entries:
+            entry.details = _dedupe_preserve_order(entry.details)
+
+    return merged
+
+
+def _render_report_markdown(
+    preamble: list[str],
+    sections: dict[str, list[ReportEntry]],
+) -> str:
+    lines: list[str] = []
+    if preamble:
+        lines.extend(preamble)
+        if lines and lines[-1].strip():
+            lines.append("")
+
+    for section, entries in sections.items():
+        lines.append(section)
+        for entry in entries:
+            lines.append(f"  - {entry.summary}")
+            for detail in entry.details:
+                lines.append(f"    - {detail}")
+        lines.append("")
+
+    while lines and not lines[-1].strip():
+        lines.pop()
+
+    return "\n".join(lines) + "\n"
+
+
+def merge_report_content(existing: str, new: str) -> str:
+    existing_preamble, existing_sections = _parse_report_markdown(existing)
+    new_preamble, new_sections = _parse_report_markdown(new)
+
+    preamble = existing_preamble or new_preamble
+    merged_sections = _merge_sections(existing_sections, new_sections)
+    return _render_report_markdown(preamble, merged_sections)
+
+
+def get_storage_dir(base_dir: Optional[Path] = None) -> Path:
+    """获取存储目录
+
+    Args:
+        base_dir: 基础目录，默认为 ~/.weekly-reports
+
+    Returns:
+        存储目录路径
+    """
+    if base_dir is not None:
+        return base_dir
+
+    return Path.home() / ".weekly-reports"
+
+
+def get_report_path(
+    year: int,
+    week: int,
+    base_dir: Optional[Path] = None,
+) -> Path:
+    """获取周报文件路径
+
+    Args:
+        year: 年份
+        week: 周数
+        base_dir: 存储基础目录
+
+    Returns:
+        周报文件路径
+    """
+    storage_dir = get_storage_dir(base_dir)
+    return storage_dir / str(year) / f"week-{week:02d}.md"
+
+
+def save_report(
+    content: str,
+    year: int,
+    week: int,
+    base_dir: Optional[Path] = None,
+) -> Path:
+    """保存周报
+
+    Args:
+        content: 周报内容
+        year: 年份
+        week: 周数
+        base_dir: 存储基础目录
+
+    Returns:
+        保存的文件路径
+    """
+    path = get_report_path(year, week, base_dir)
+
+    # 确保目录存在
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    # 同一周多次生成时进行内容合并
+    if path.exists():
+        existing = path.read_text(encoding="utf-8")
+        merged = merge_report_content(existing, content)
+        path.write_text(merged, encoding="utf-8")
+    else:
+        path.write_text(content if content.endswith("\n") else content + "\n", encoding="utf-8")
+
+    return path
+
+
+def list_reports(base_dir: Optional[Path] = None) -> List[Dict[str, Any]]:
+    """列出所有周报
+
+    Args:
+        base_dir: 存储基础目录
+
+    Returns:
+        周报列表，每项包含 year, week, path
+    """
+    storage_dir = get_storage_dir(base_dir)
+
+    if not storage_dir.exists():
+        return []
+
+    reports = []
+
+    # 遍历年份目录
+    for year_dir in sorted(storage_dir.iterdir(), reverse=True):
+        if not year_dir.is_dir() or not year_dir.name.isdigit():
+            continue
+
+        year = int(year_dir.name)
+
+        # 遍历周报文件
+        for report_file in sorted(year_dir.glob("week-*.md"), reverse=True):
+            # 从文件名提取周数
+            week_str = report_file.stem.replace("week-", "")
+            try:
+                week = int(week_str)
+            except ValueError:
+                continue
+
+            reports.append({
+                "year": year,
+                "week": week,
+                "path": report_file,
+                "filename": report_file.name,
+            })
+
+    return reports
+
+
+def get_report_by_week(
+    year: int,
+    week: int,
+    base_dir: Optional[Path] = None,
+) -> Optional[Dict[str, Any]]:
+    """按周获取周报
+
+    Args:
+        year: 年份
+        week: 周数
+        base_dir: 存储基础目录
+
+    Returns:
+        周报信息字典，不存在时返回 None
+    """
+    path = get_report_path(year, week, base_dir)
+
+    if not path.exists():
+        return None
+
+    return {
+        "year": year,
+        "week": week,
+        "path": path,
+        "content": path.read_text(encoding="utf-8"),
+    }
+
+
+def update_index(base_dir: Optional[Path] = None) -> None:
+    """更新周报索引文件
+
+    Args:
+        base_dir: 存储基础目录
+    """
+    storage_dir = get_storage_dir(base_dir)
+    storage_dir.mkdir(parents=True, exist_ok=True)
+
+    reports = list_reports(base_dir)
+
+    # 按年份分组
+    by_year: Dict[int, List[Dict[str, Any]]] = {}
+    for report in reports:
+        year = report["year"]
+        if year not in by_year:
+            by_year[year] = []
+        by_year[year].append(report)
+
+    # 生成索引内容
+    lines = ["# 周报索引\n"]
+
+    for year in sorted(by_year.keys(), reverse=True):
+        lines.append(f"\n## {year} 年\n")
+        for report in by_year[year]:
+            week = report["week"]
+            filename = report["filename"]
+            lines.append(f"- [第 {week} 周](./{year}/{filename})")
+
+    # 如果没有周报
+    if not reports:
+        lines.append("\n暂无周报记录。\n")
+
+    # 写入索引文件
+    index_path = storage_dir / "index.md"
+    index_path.write_text("\n".join(lines), encoding="utf-8")
+
+
+def delete_report(
+    year: int,
+    week: int,
+    base_dir: Optional[Path] = None,
+) -> bool:
+    """删除周报
+
+    Args:
+        year: 年份
+        week: 周数
+        base_dir: 存储基础目录
+
+    Returns:
+        是否成功删除
+    """
+    path = get_report_path(year, week, base_dir)
+
+    if not path.exists():
+        return False
+
+    path.unlink()
+    return True
+
+
+# ==================== 时间段报告相关函数 ====================
+
+
+def get_period_report_path(
+    start_date: date,
+    end_date: date,
+    base_dir: Optional[Path] = None,
+) -> Path:
+    """获取时间段报告文件路径
+
+    Args:
+        start_date: 开始日期
+        end_date: 结束日期
+        base_dir: 存储基础目录
+
+    Returns:
+        时间段报告文件路径，格式为 periods/YYYY-MM-DD_to_YYYY-MM-DD.md
+    """
+    storage_dir = get_storage_dir(base_dir)
+    filename = f"{start_date.isoformat()}_to_{end_date.isoformat()}.md"
+    return storage_dir / "periods" / filename
+
+
+def save_period_report(
+    content: str,
+    start_date: date,
+    end_date: date,
+    base_dir: Optional[Path] = None,
+) -> Path:
+    """保存时间段报告
+
+    Args:
+        content: 报告内容
+        start_date: 开始日期
+        end_date: 结束日期
+        base_dir: 存储基础目录
+
+    Returns:
+        保存的文件路径
+    """
+    path = get_period_report_path(start_date, end_date, base_dir)
+
+    # 确保目录存在
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    # 同一时间段多次生成时进行内容合并
+    if path.exists():
+        existing = path.read_text(encoding="utf-8")
+        merged = merge_report_content(existing, content)
+        path.write_text(merged, encoding="utf-8")
+    else:
+        path.write_text(content if content.endswith("\n") else content + "\n", encoding="utf-8")
+
+    return path
+
+
+def list_period_reports(base_dir: Optional[Path] = None) -> List[Dict[str, Any]]:
+    """列出所有时间段报告
+
+    Args:
+        base_dir: 存储基础目录
+
+    Returns:
+        时间段报告列表，每项包含 start_date, end_date, path, filename
+    """
+    storage_dir = get_storage_dir(base_dir)
+    periods_dir = storage_dir / "periods"
+
+    if not periods_dir.exists():
+        return []
+
+    reports = []
+
+    # 遍历时间段报告文件
+    for report_file in sorted(periods_dir.glob("*_to_*.md"), reverse=True):
+        # 从文件名提取日期范围
+        stem = report_file.stem  # e.g., "2025-07-13_to_2026-01-13"
+        parts = stem.split("_to_")
+        if len(parts) != 2:
+            continue
+
+        try:
+            start_date = date.fromisoformat(parts[0])
+            end_date = date.fromisoformat(parts[1])
+        except ValueError:
+            continue
+
+        reports.append({
+            "start_date": start_date,
+            "end_date": end_date,
+            "path": report_file,
+            "filename": report_file.name,
+        })
+
+    return reports
+
+
+def get_period_report(
+    start_date: date,
+    end_date: date,
+    base_dir: Optional[Path] = None,
+) -> Optional[Dict[str, Any]]:
+    """按日期范围获取时间段报告
+
+    Args:
+        start_date: 开始日期
+        end_date: 结束日期
+        base_dir: 存储基础目录
+
+    Returns:
+        报告信息字典，不存在时返回 None
+    """
+    path = get_period_report_path(start_date, end_date, base_dir)
+
+    if not path.exists():
+        return None
+
+    return {
+        "start_date": start_date,
+        "end_date": end_date,
+        "path": path,
+        "content": path.read_text(encoding="utf-8"),
+    }
+
+
+def delete_period_report(
+    start_date: date,
+    end_date: date,
+    base_dir: Optional[Path] = None,
+) -> bool:
+    """删除时间段报告
+
+    Args:
+        start_date: 开始日期
+        end_date: 结束日期
+        base_dir: 存储基础目录
+
+    Returns:
+        是否成功删除
+    """
+    path = get_period_report_path(start_date, end_date, base_dir)
+
+    if not path.exists():
+        return False
+
+    path.unlink()
+    return True

package/uninstall-skill.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const { getEnabledTargets, extractSkillName, detectInstallLocation } = require('./utils');
+
+function uninstallFromTarget(target, config) {
+  console.log(`\n🗑️  Uninstalling from ${target.name}...`);
+
+  const isGlobal = process.env.npm_config_global === 'true';
+  const location = detectInstallLocation(target.paths, isGlobal);
+
+  // Extract skill name from package name (remove scope prefix)
+  const skillName = extractSkillName(config.name);
+
+  // Path format using skill name
+  const skillNameTargetDir = path.join(location.base, skillName);
+
+  // Path format with full package name (including scope)
+  const fullPackageNameTargetDir = path.join(location.base, config.name);
+
+  let removed = false;
+
+  // Check and remove path using skill name
+  if (fs.existsSync(skillNameTargetDir)) {
+    fs.rmSync(skillNameTargetDir, { recursive: true, force: true });
+    console.log(`  ✓ Removed skill directory: ${skillName}`);
+    removed = true;
+  }
+
+  // Check and remove path with full package name (for compatibility)
+  if (fs.existsSync(fullPackageNameTargetDir) && fullPackageNameTargetDir !== skillNameTargetDir) {
+    fs.rmSync(fullPackageNameTargetDir, { recursive: true, force: true });
+    console.log(`  ✓ Removed skill directory: ${config.name}`);
+    removed = true;
+  }
+
+  // Update manifest
+  const manifestPath = path.join(location.base, '.skills-manifest.json');
+  if (fs.existsSync(manifestPath)) {
+    try {
+      const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+      if (manifest.skills && manifest.skills[config.name]) {
+        delete manifest.skills[config.name];
+        fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+        console.log(`  ✓ Updated manifest`);
+      }
+    } catch (error) {
+      console.warn('  Warning: Could not update manifest:', error.message);
+    }
+  }
+
+  if (removed) {
+    console.log(`  ✅ Uninstalled from ${target.name}`);
+    return true;
+  } else {
+    console.log(`  ℹ️  Skill was not installed in ${target.name}`);
+    return false;
+  }
+}
+
+function uninstallSkill() {
+  console.log('🗑️  Uninstalling AI Coding Skill...\n');
+
+  // Read configuration
+  const configPath = path.join(__dirname, '.claude-skill.json');
+  if (!fs.existsSync(configPath)) {
+    console.warn('Warning: .claude-skill.json not found, skipping cleanup');
+    return;
+  }
+
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+
+  // Get enabled targets
+  const enabledTargets = getEnabledTargets(config);
+
+  console.log(`Uninstalling skill "${config.name}" from ${enabledTargets.length} target(s):`);
+  enabledTargets.forEach(target => {
+    console.log(`  • ${target.name}`);
+  });
+
+  // Uninstall from all enabled targets
+  const uninstalledFrom = [];
+  for (const target of enabledTargets) {
+    try {
+      const success = uninstallFromTarget(target, config);
+      if (success) {
+        uninstalledFrom.push(target.name);
+      }
+    } catch (error) {
+      console.error(`\n❌ Failed to uninstall from ${target.name}:`, error.message);
+    }
+  }
+
+  // Summary
+  console.log('\n' + '='.repeat(60));
+  if (uninstalledFrom.length > 0) {
+    console.log('✅ Uninstallation Complete!');
+    console.log('='.repeat(60));
+    console.log('\nUninstalled from:');
+    uninstalledFrom.forEach(target => {
+      console.log(`  • ${target}`);
+    });
+  } else {
+    console.log('ℹ️  Skill was not installed');
+    console.log('='.repeat(60));
+  }
+}
+
+// Execute uninstall
+try {
+  uninstallSkill();
+} catch (error) {
+  console.error('\n⚠️  Warning during uninstall:', error.message);
+  // Don't exit with error code as uninstall should be best-effort
+}

package/utils.js

@@ -0,0 +1,94 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CWD = process.env.INIT_CWD || process.cwd();
+
+/**
+ * Get enabled target configurations
+ */
+function getEnabledTargets(config) {
+  // If no targets configuration, use default Claude Code configuration
+  if (!config.targets) {
+    return [{
+      name: 'claude-code',
+      paths: {
+        global: '.claude/skills',
+        project: '.claude/skills'
+      }
+    }];
+  }
+
+  // Return all enabled targets
+  return Object.entries(config.targets)
+    .filter(([_, target]) => target.enabled)
+    .map(([name, target]) => ({
+      name,
+      paths: target.paths
+    }));
+}
+
+/**
+ * Extract skill name from package name (remove scope prefix)
+ */
+function extractSkillName(packageName) {
+  return packageName.startsWith('@') ?
+    packageName.split('/')[1] || packageName :
+    packageName;
+}
+
+/**
+ * Detect installation location
+ */
+function detectInstallLocation(targetPaths, isGlobal) {
+  if (isGlobal) {
+    // Global installation: install to user home directory
+    return {
+      type: 'personal',
+      base: path.join(os.homedir(), targetPaths.global)
+    };
+  } else {
+    // Project-level installation: find the actual project root directory
+    let projectRoot = CWD;
+
+    // Search upward, skip node_modules directories, find the actual project root
+    while (projectRoot !== path.dirname(projectRoot)) {
+      // Check if this is a project root directory (contains package.json or .git)
+      const hasPackageJson = fs.existsSync(path.join(projectRoot, 'package.json'));
+      const hasGit = fs.existsSync(path.join(projectRoot, '.git'));
+
+      // Check if current directory is in node_modules
+      const isInNodeModules = projectRoot.includes('/node_modules/') ||
+                             path.basename(projectRoot) === 'node_modules';
+
+      if ((hasPackageJson || hasGit) && !isInNodeModules) {
+        // Found the actual project root directory
+        break;
+      }
+
+      // Continue searching upward
+      projectRoot = path.dirname(projectRoot);
+    }
+
+    // Verify the final path is reasonable
+    const finalIsInNodeModules = projectRoot.includes('/node_modules/') ||
+                                path.basename(projectRoot) === 'node_modules';
+
+    if (finalIsInNodeModules) {
+      // If suitable project root not found, use current working directory (with warning)
+      console.warn('⚠ Warning: Could not find project root directory, using current directory');
+      projectRoot = CWD;
+    }
+
+    return {
+      type: 'project',
+      base: path.join(projectRoot, targetPaths.project)
+    };
+  }
+}
+
+module.exports = {
+  getEnabledTargets,
+  extractSkillName,
+  detectInstallLocation
+};