feat: 结题报告初稿助手首版 v1.0.1（draft-closing-report-default）
All checks were successful
技能自动化发布 / release (push) Successful in 6s
All checks were successful
技能自动化发布 / release (push) Successful in 6s
This commit is contained in:
chenfuqiang
240
scripts/cli/app.py
Normal file
240
scripts/cli/app.py
Normal file
@@ -0,0 +1,240 @@
|
||||
"""CLI：argparse 与分发（结题报告初稿助手）。
|
||||
|
||||
只负责参数解析并转交 service；业务内核在 draft_service / ledger_service / docx_service，
|
||||
勿在此按入口复制逻辑。
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import sys
|
||||
from typing import List, Optional
|
||||
|
||||
from service.task_service import (
|
||||
cmd_add_achievement,
|
||||
cmd_add_expense,
|
||||
cmd_add_project,
|
||||
cmd_config_path,
|
||||
cmd_draft_batch_pending,
|
||||
cmd_draft_report,
|
||||
cmd_health,
|
||||
cmd_import,
|
||||
cmd_init_db,
|
||||
cmd_list,
|
||||
cmd_list_drafts,
|
||||
cmd_render_html,
|
||||
cmd_run,
|
||||
cmd_show_draft,
|
||||
cmd_stats,
|
||||
cmd_version,
|
||||
)
|
||||
from util.config_bootstrap import bootstrap_skill_config
|
||||
from util.argparse_zh import ZhArgumentParser
|
||||
from util.constants import LOG_LOGGER_NAME, SKILL_SLUG
|
||||
from util.logging_config import get_skill_logger, setup_skill_logging
|
||||
|
||||
|
||||
def _cli_str_or_none(raw: Optional[str]) -> Optional[str]:
|
||||
if raw is None:
|
||||
return None
|
||||
v = str(raw).strip()
|
||||
return v or None
|
||||
|
||||
|
||||
def _cli_float_or_none(raw: Optional[str]) -> Optional[float]:
|
||||
raw = _cli_str_or_none(raw)
|
||||
if raw is None:
|
||||
return None
|
||||
try:
|
||||
return float(raw)
|
||||
except ValueError:
|
||||
return None
|
||||
|
||||
|
||||
def _handle_run(args: argparse.Namespace) -> int:
|
||||
tail = [str(x).strip() for x in (args.run_tail or []) if str(x).strip()]
|
||||
if len(tail) > 2:
|
||||
print("参数过多。")
|
||||
print("用法：python main.py run [target [input_id]] | run [-t target] [-i input_id]")
|
||||
return 1
|
||||
t_target: Optional[str] = None
|
||||
t_input: Optional[str] = None
|
||||
if len(tail) == 2:
|
||||
t_target, t_input = tail[0], tail[1]
|
||||
elif len(tail) == 1:
|
||||
if tail[0].isdigit():
|
||||
t_input = tail[0]
|
||||
else:
|
||||
t_target = tail[0]
|
||||
target = _cli_str_or_none(getattr(args, "target", None)) or t_target
|
||||
input_id = _cli_str_or_none(getattr(args, "input_id", None)) or t_input
|
||||
return cmd_run(target=target, input_id=input_id)
|
||||
|
||||
|
||||
def _handle_add_project(args: argparse.Namespace) -> int:
|
||||
return cmd_add_project(
|
||||
project_no=str(args.project_no or "").strip(),
|
||||
name=_cli_str_or_none(args.name) or "",
|
||||
pi=_cli_str_or_none(args.pi) or "",
|
||||
department=_cli_str_or_none(args.department) or "",
|
||||
program=_cli_str_or_none(args.program) or "",
|
||||
start=_cli_str_or_none(args.start) or "",
|
||||
end=_cli_str_or_none(args.end) or "",
|
||||
expected_json=_cli_str_or_none(args.expected_json) or "",
|
||||
excerpt=_cli_str_or_none(args.excerpt) or "",
|
||||
status=_cli_str_or_none(args.status) or "",
|
||||
)
|
||||
|
||||
|
||||
def _handle_import(args: argparse.Namespace) -> int:
|
||||
return cmd_import(
|
||||
projects_json=_cli_str_or_none(args.projects_json) or "",
|
||||
achievements_json=_cli_str_or_none(args.achievements_json) or "",
|
||||
expenses_json=_cli_str_or_none(args.expenses_json) or "",
|
||||
)
|
||||
|
||||
|
||||
def _handle_list(args: argparse.Namespace) -> int:
|
||||
return cmd_list(
|
||||
kind=_cli_str_or_none(args.kind) or "projects",
|
||||
project_no=_cli_str_or_none(args.project_no) or "",
|
||||
status=_cli_str_or_none(args.status) or "",
|
||||
)
|
||||
|
||||
|
||||
def _handle_render_html(args: argparse.Namespace) -> int:
|
||||
report_id = getattr(args, "report_id", None)
|
||||
return cmd_render_html(report_id=int(report_id) if report_id else None)
|
||||
|
||||
|
||||
def _print_full_usage() -> None:
|
||||
print("结题报告初稿助手（main.py）可用命令：")
|
||||
print(" python main.py add-project --project-no X --name Y [--pi 张三] [--program 国自然青年] [--start D] [--end D]")
|
||||
print(" [--expected-json '[{\"type\":\"论文\",\"target\":3,\"unit\":\"篇\"}]'] [--excerpt 摘句] [--status 待结题]")
|
||||
print(" python main.py add-achievement --project-no X --type 论文 --title T [--venue 期刊] [--date D] [--representative 1]")
|
||||
print(" python main.py add-expense --project-no X --category 差旅费 --amount 23000 [--date D] [--description 摘要]")
|
||||
print(" python main.py import --projects-json F [--achievements-json F] [--expenses-json F]")
|
||||
print(" python main.py list [projects|achievements|expenses] [--project-no X] [--status 待结题]")
|
||||
print(" python main.py draft-report --project-no X # 主命令：生成 Word 初稿 + HTML 预览")
|
||||
print(" python main.py draft-batch-pending # 批量生成全部待结题初稿")
|
||||
print(" python main.py list-drafts [--limit N] | show-draft --id N | render-html [--report-id N]")
|
||||
print(" python main.py stats")
|
||||
print(" python main.py run [target [input_id]] [-t target] [-i input_id]")
|
||||
print(" python main.py health | config-path | version | init-db")
|
||||
|
||||
|
||||
def build_parser() -> ZhArgumentParser:
|
||||
p = ZhArgumentParser(
|
||||
prog="main.py",
|
||||
description="结题报告初稿助手：对比预期指标与实际成果生成完成情况章节，决算明细转规范描述，组装可修改的 Word 版《结题报告（初稿）》。",
|
||||
formatter_class=argparse.RawDescriptionHelpFormatter,
|
||||
)
|
||||
sub = p.add_subparsers(dest="cmd", required=True, parser_class=ZhArgumentParser)
|
||||
|
||||
sp = sub.add_parser("add-project", help="录入/更新结题项目（按项目编号幂等）")
|
||||
sp.add_argument("--project-no", required=True, metavar="项目编号", dest="project_no")
|
||||
sp.add_argument("--name", default=None, metavar="项目名称")
|
||||
sp.add_argument("--pi", default=None, metavar="负责人")
|
||||
sp.add_argument("--department", default=None, metavar="所属学院")
|
||||
sp.add_argument("--program", default=None, metavar="项目类型")
|
||||
sp.add_argument("--start", default=None, metavar="执行期开始")
|
||||
sp.add_argument("--end", default=None, metavar="执行期结束")
|
||||
sp.add_argument("--expected-json", default=None, metavar="预期指标JSON", dest="expected_json")
|
||||
sp.add_argument("--excerpt", default=None, metavar="年度报告摘句")
|
||||
sp.add_argument("--status", default=None, metavar="状态(待结题/初稿已生成/已提交)")
|
||||
sp.set_defaults(handler=_handle_add_project)
|
||||
|
||||
sp = sub.add_parser("add-achievement", help="录入成果")
|
||||
sp.add_argument("--project-no", required=True, metavar="项目编号", dest="project_no")
|
||||
sp.add_argument("--type", required=True, metavar="类型(论文/专利/人才培养/其他)", dest="ach_type")
|
||||
sp.add_argument("--title", required=True, metavar="成果名称")
|
||||
sp.add_argument("--venue", default=None, metavar="期刊/专利号")
|
||||
sp.add_argument("--date", default=None, metavar="日期")
|
||||
sp.add_argument("--representative", default=None, metavar="代表性(1/0)")
|
||||
sp.add_argument("--note", default=None, metavar="备注")
|
||||
sp.set_defaults(
|
||||
handler=lambda a: cmd_add_achievement(
|
||||
project_no=str(a.project_no), ach_type=str(a.ach_type), title=str(a.title),
|
||||
venue=_cli_str_or_none(a.venue) or "", date=_cli_str_or_none(a.date) or "",
|
||||
representative=_cli_str_or_none(a.representative) or "", note=_cli_str_or_none(a.note) or "",
|
||||
)
|
||||
)
|
||||
|
||||
sp = sub.add_parser("add-expense", help="录入决算明细")
|
||||
sp.add_argument("--project-no", required=True, metavar="项目编号", dest="project_no")
|
||||
sp.add_argument("--category", required=True, metavar="科目")
|
||||
sp.add_argument("--amount", required=True, type=float, metavar="金额(元)")
|
||||
sp.add_argument("--date", default=None, metavar="发生日期")
|
||||
sp.add_argument("--description", default=None, metavar="原始摘要")
|
||||
sp.set_defaults(
|
||||
handler=lambda a: cmd_add_expense(
|
||||
project_no=str(a.project_no), category=str(a.category), amount=float(a.amount),
|
||||
date=_cli_str_or_none(a.date) or "", description=_cli_str_or_none(a.description) or "",
|
||||
)
|
||||
)
|
||||
|
||||
sp = sub.add_parser("import", help="批量导入（projects/achievements/expenses JSON）")
|
||||
sp.add_argument("--projects-json", default=None, metavar="项目JSON(file|-)", dest="projects_json")
|
||||
sp.add_argument("--achievements-json", default=None, metavar="成果JSON(file|-)", dest="achievements_json")
|
||||
sp.add_argument("--expenses-json", default=None, metavar="决算JSON(file|-)", dest="expenses_json")
|
||||
sp.set_defaults(handler=_handle_import)
|
||||
|
||||
sp = sub.add_parser("list", help="查询台账（projects/achievements/expenses）")
|
||||
sp.add_argument("--kind", default="projects", metavar="projects|achievements|expenses", dest="kind")
|
||||
sp.add_argument("--project-no", default=None, metavar="项目编号", dest="project_no")
|
||||
sp.add_argument("--status", default=None, metavar="状态筛选")
|
||||
sp.set_defaults(handler=_handle_list)
|
||||
|
||||
sp = sub.add_parser("draft-report", help="生成结题报告初稿（主命令）")
|
||||
sp.add_argument("--project-no", required=True, metavar="项目编号", dest="project_no")
|
||||
sp.set_defaults(handler=lambda a: cmd_draft_report(project_no=str(a.project_no)))
|
||||
|
||||
sp = sub.add_parser("draft-batch-pending", help="批量生成全部待结题项目初稿")
|
||||
sp.set_defaults(handler=lambda _a: cmd_draft_batch_pending())
|
||||
|
||||
sp = sub.add_parser("list-drafts", help="查询初稿记录")
|
||||
sp.add_argument("--limit", default=20, metavar="条数")
|
||||
sp.set_defaults(handler=lambda a: cmd_list_drafts(limit=int(a.limit or 20)))
|
||||
|
||||
sp = sub.add_parser("show-draft", help="查看初稿记录详情")
|
||||
sp.add_argument("--id", required=True, type=int, metavar="记录编号", dest="draft_id")
|
||||
sp.set_defaults(handler=lambda a: cmd_show_draft(draft_id=int(a.draft_id)))
|
||||
|
||||
sp = sub.add_parser("render-html", help="重建 HTML 预览（缺省最近 10 份）")
|
||||
sp.add_argument("--report-id", default=None, metavar="记录编号", dest="report_id")
|
||||
sp.set_defaults(handler=_handle_render_html)
|
||||
|
||||
sp = sub.add_parser("stats", help="统计")
|
||||
sp.set_defaults(handler=lambda _a: cmd_stats())
|
||||
|
||||
sp = sub.add_parser("run", help="任务执行命令骨架")
|
||||
sp.add_argument("--target", "-t", default=None, metavar="目标")
|
||||
sp.add_argument("--input-id", "-i", default=None, metavar="输入id", dest="input_id")
|
||||
sp.add_argument("run_tail", nargs="*", metavar="位置参数")
|
||||
sp.set_defaults(handler=_handle_run)
|
||||
|
||||
sp = sub.add_parser("health", help="健康检查")
|
||||
sp.set_defaults(handler=lambda _a: cmd_health())
|
||||
|
||||
sp = sub.add_parser("config-path", help="输出用户 .env 与模板路径")
|
||||
sp.set_defaults(handler=lambda _a: cmd_config_path())
|
||||
|
||||
sp = sub.add_parser("version", help="版本信息(JSON)")
|
||||
sp.set_defaults(handler=lambda _a: cmd_version())
|
||||
|
||||
sp = sub.add_parser("init-db", help="幂等初始化本地数据库与数据管理元数据")
|
||||
sp.set_defaults(handler=lambda _a: cmd_init_db())
|
||||
return p
|
||||
|
||||
|
||||
def main(argv: Optional[List[str]] = None) -> int:
|
||||
argv = argv if argv is not None else sys.argv[1:]
|
||||
bootstrap_skill_config()
|
||||
setup_skill_logging(SKILL_SLUG, LOG_LOGGER_NAME)
|
||||
get_skill_logger().info("cli_start argv=%s", sys.argv)
|
||||
if not argv:
|
||||
_print_full_usage()
|
||||
return 1
|
||||
parser = build_parser()
|
||||
args = parser.parse_args(argv)
|
||||
return int(args.handler(args))
|
||||
262
scripts/db/connection.py
Normal file
262
scripts/db/connection.py
Normal file
@@ -0,0 +1,262 @@
|
||||
"""SQLite 连接与幂等初始化（结题报告初稿助手）。
|
||||
|
||||
业务表 4 张：
|
||||
- closing_projects（结题项目，含预期指标，可编辑）
|
||||
- achievements（成果清单，可编辑）
|
||||
- expense_items（决算明细，可编辑）
|
||||
- report_drafts（初稿记录，只读，生成自动写入）
|
||||
|
||||
表间禁止 SQLite 外键，仅存业务 id（见 references/SCHEMA.md）。
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import sqlite3
|
||||
|
||||
from db.display_metadata import (
|
||||
init_display_metadata,
|
||||
seed_column_metadata_batch,
|
||||
upsert_table_metadata,
|
||||
)
|
||||
from db.timestamp_columns import init_updated_at_trigger
|
||||
from util.runtime_paths import get_db_path
|
||||
|
||||
|
||||
def get_conn() -> sqlite3.Connection:
|
||||
return sqlite3.connect(get_db_path())
|
||||
|
||||
|
||||
_CLOSING_PROJECTS_DDL = """
|
||||
CREATE TABLE IF NOT EXISTS closing_projects (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
project_no TEXT NOT NULL UNIQUE,
|
||||
project_name TEXT,
|
||||
pi_name TEXT,
|
||||
department TEXT,
|
||||
program TEXT,
|
||||
start_date TEXT,
|
||||
end_date TEXT,
|
||||
expected_json TEXT,
|
||||
annual_report_excerpt TEXT,
|
||||
status TEXT NOT NULL DEFAULT '待结题',
|
||||
created_at INTEGER NOT NULL DEFAULT (unixepoch()),
|
||||
updated_at INTEGER NOT NULL DEFAULT (unixepoch())
|
||||
)
|
||||
"""
|
||||
|
||||
_ACHIEVEMENTS_DDL = """
|
||||
CREATE TABLE IF NOT EXISTS achievements (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
project_no TEXT NOT NULL,
|
||||
achievement_type TEXT NOT NULL,
|
||||
title TEXT,
|
||||
venue_or_no TEXT,
|
||||
ach_date TEXT,
|
||||
is_representative INTEGER NOT NULL DEFAULT 0,
|
||||
note TEXT,
|
||||
created_at INTEGER NOT NULL DEFAULT (unixepoch()),
|
||||
updated_at INTEGER NOT NULL DEFAULT (unixepoch())
|
||||
)
|
||||
"""
|
||||
|
||||
_EXPENSE_ITEMS_DDL = """
|
||||
CREATE TABLE IF NOT EXISTS expense_items (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
project_no TEXT NOT NULL,
|
||||
category TEXT NOT NULL,
|
||||
amount REAL NOT NULL,
|
||||
occurred_date TEXT,
|
||||
description TEXT,
|
||||
created_at INTEGER NOT NULL DEFAULT (unixepoch()),
|
||||
updated_at INTEGER NOT NULL DEFAULT (unixepoch())
|
||||
)
|
||||
"""
|
||||
|
||||
_REPORT_DRAFTS_DDL = """
|
||||
CREATE TABLE IF NOT EXISTS report_drafts (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
batch_no TEXT NOT NULL,
|
||||
project_no TEXT,
|
||||
project_name TEXT,
|
||||
completion_json TEXT,
|
||||
narrative_points_json TEXT,
|
||||
draft_file TEXT,
|
||||
preview_file TEXT,
|
||||
created_at INTEGER NOT NULL DEFAULT (unixepoch())
|
||||
)
|
||||
"""
|
||||
|
||||
_REPORT_DRAFTS_INDEX = """
|
||||
CREATE INDEX IF NOT EXISTS idx_report_drafts_batch
|
||||
ON report_drafts(batch_no)
|
||||
"""
|
||||
|
||||
_TS_COLUMN_NAMES = {"created_at", "updated_at"}
|
||||
|
||||
|
||||
def _col(column_name: str, display_name: str, description: str, **extra: object) -> dict[str, object]:
|
||||
base: dict[str, object] = {
|
||||
"column_name": column_name,
|
||||
"display_name": display_name,
|
||||
"description": description,
|
||||
"visible": 1,
|
||||
"searchable": 0,
|
||||
"editable": 0,
|
||||
}
|
||||
base.update(extra)
|
||||
if column_name in _TS_COLUMN_NAMES:
|
||||
base["display_type"] = "datetime_unix_seconds"
|
||||
return base
|
||||
|
||||
|
||||
_CLOSING_PROJECTS_COLUMNS: tuple[dict[str, object], ...] = (
|
||||
_col("id", "编号", "主键", searchable=1),
|
||||
_col("project_no", "项目编号", "项目唯一编号。", searchable=1),
|
||||
_col("project_name", "项目名称", "项目全称。", searchable=1, editable=1),
|
||||
_col("pi_name", "负责人", "项目负责人姓名。", searchable=1, editable=1),
|
||||
_col("department", "所属学院", "二级学院/单位。", searchable=1, editable=1),
|
||||
_col("program", "项目类型", "如 国家自然科学基金（青年/面上）。", searchable=1, editable=1),
|
||||
_col("start_date", "执行期开始", "YYYY-MM-DD。", searchable=1, editable=1),
|
||||
_col("end_date", "执行期结束", "YYYY-MM-DD。", searchable=1, editable=1),
|
||||
_col("expected_json", "预期成果指标", "如 [{\"type\":\"论文\",\"target\":3,\"unit\":\"篇\"}]。", visible=0, display_type="textarea", editable=1),
|
||||
_col("annual_report_excerpt", "年度报告摘句", "年度/中期报告关键句（分号分隔），供叙事素材。", visible=0, display_type="textarea", editable=1),
|
||||
_col("status", "状态", "待结题 / 初稿已生成 / 已提交。", searchable=1, editable=1, options_json='[{"value":"待结题","label":"待结题"},{"value":"初稿已生成","label":"初稿已生成"},{"value":"已提交","label":"已提交"}]'),
|
||||
_col("created_at", "创建时间", "记录创建时间（Unix 秒级，自动生成）。"),
|
||||
_col("updated_at", "更新时间", "记录最后更新时间（Unix 秒级，自动维护）。"),
|
||||
)
|
||||
|
||||
_ACHIEVEMENTS_COLUMNS: tuple[dict[str, object], ...] = (
|
||||
_col("id", "编号", "主键", searchable=1),
|
||||
_col("project_no", "项目编号", "所属项目编号。", searchable=1),
|
||||
_col("achievement_type", "成果类型", "论文 / 专利 / 人才培养 / 其他。", searchable=1, editable=1, options_json='[{"value":"论文","label":"论文"},{"value":"专利","label":"专利"},{"value":"人才培养","label":"人才培养"},{"value":"其他","label":"其他"}]'),
|
||||
_col("title", "成果名称", "论文标题/专利名/成果描述。", searchable=1, editable=1),
|
||||
_col("venue_or_no", "期刊/专利号", "发表期刊或专利号。", editable=1),
|
||||
_col("ach_date", "日期", "发表/授权日期（YYYY-MM-DD）。", editable=1),
|
||||
_col("is_representative", "代表性成果", "1=代表本项目的标志性成果。", searchable=1, editable=1),
|
||||
_col("note", "备注", "说明。", editable=1),
|
||||
_col("created_at", "创建时间", "记录创建时间（Unix 秒级，自动生成）。"),
|
||||
_col("updated_at", "更新时间", "记录最后更新时间（Unix 秒级，自动维护）。"),
|
||||
)
|
||||
|
||||
_EXPENSE_ITEMS_COLUMNS: tuple[dict[str, object], ...] = (
|
||||
_col("id", "编号", "主键", searchable=1),
|
||||
_col("project_no", "项目编号", "所属项目编号。", searchable=1),
|
||||
_col("category", "科目", "决算科目，如 差旅费、设备费。", searchable=1, editable=1),
|
||||
_col("amount", "金额", "支出金额（元）。", searchable=1, editable=1, display_type="number"),
|
||||
_col("occurred_date", "发生日期", "YYYY-MM-DD。", editable=1),
|
||||
_col("description", "原始摘要", "流水描述，供语义化转换参考。", visible=0, display_type="textarea", editable=1),
|
||||
_col("created_at", "创建时间", "记录创建时间（Unix 秒级，自动生成）。"),
|
||||
_col("updated_at", "更新时间", "记录最后更新时间（Unix 秒级，自动维护）。"),
|
||||
)
|
||||
|
||||
_REPORT_DRAFTS_COLUMNS: tuple[dict[str, object], ...] = (
|
||||
_col("id", "记录编号", "主键，初稿记录编号。", searchable=1),
|
||||
_col("batch_no", "生成批次号", "同一次生成请求的批次号。", searchable=1),
|
||||
_col("project_no", "项目编号", "初稿对应项目。", searchable=1),
|
||||
_col("project_name", "项目名称", "初稿对应项目名。", searchable=1),
|
||||
_col("completion_json", "指标对比", "预期 vs 实际对比（JSON）。", visible=0, display_type="textarea"),
|
||||
_col("narrative_points_json", "叙事素材要点", "从成果与年度报告提取的要点（JSON）。", visible=0, display_type="textarea"),
|
||||
_col("draft_file", "Word 初稿", "生成的 docx 文件路径。", visible=0),
|
||||
_col("preview_file", "预览文件", "HTML 预览文件路径。", visible=0),
|
||||
_col("created_at", "创建时间", "记录创建时间（Unix 秒级，自动生成）。"),
|
||||
)
|
||||
|
||||
|
||||
def _init_closing_projects_metadata(cursor) -> None:
|
||||
cursor.execute(_CLOSING_PROJECTS_DDL)
|
||||
init_updated_at_trigger(cursor, "closing_projects")
|
||||
upsert_table_metadata(
|
||||
cursor,
|
||||
table_name="closing_projects",
|
||||
display_name="结题项目",
|
||||
description="待结题项目与预期成果指标；初稿生成的数据源。",
|
||||
grid_help="预期指标为 JSON 数组（type/target/unit）；顶栏按钮可录入，行内可编辑。",
|
||||
visible=1,
|
||||
readonly=0,
|
||||
default_sort_json='[{"column":"id","direction":"desc"}]',
|
||||
default_visible_columns_json='["project_no","project_name","pi_name","program","end_date","status"]',
|
||||
)
|
||||
seed_column_metadata_batch(
|
||||
cursor,
|
||||
table_name="closing_projects",
|
||||
columns=_CLOSING_PROJECTS_COLUMNS,
|
||||
valid_column_names=[str(c["column_name"]) for c in _CLOSING_PROJECTS_COLUMNS],
|
||||
)
|
||||
|
||||
|
||||
def _init_achievements_metadata(cursor) -> None:
|
||||
cursor.execute(_ACHIEVEMENTS_DDL)
|
||||
init_updated_at_trigger(cursor, "achievements")
|
||||
upsert_table_metadata(
|
||||
cursor,
|
||||
table_name="achievements",
|
||||
display_name="成果清单",
|
||||
description="实际取得的论文/专利/人才培养等成果；完成情况章节的数据源。",
|
||||
grid_help="按项目编号关联；代表性成果会优先进入初稿素材。",
|
||||
visible=1,
|
||||
readonly=0,
|
||||
)
|
||||
seed_column_metadata_batch(
|
||||
cursor,
|
||||
table_name="achievements",
|
||||
columns=_ACHIEVEMENTS_COLUMNS,
|
||||
valid_column_names=[str(c["column_name"]) for c in _ACHIEVEMENTS_COLUMNS],
|
||||
)
|
||||
|
||||
|
||||
def _init_expense_items_metadata(cursor) -> None:
|
||||
cursor.execute(_EXPENSE_ITEMS_DDL)
|
||||
init_updated_at_trigger(cursor, "expense_items")
|
||||
upsert_table_metadata(
|
||||
cursor,
|
||||
table_name="expense_items",
|
||||
display_name="决算明细",
|
||||
description="经费流水明细；决算章节的数据源。",
|
||||
grid_help="金额单位元；按科目汇总后自动生成规范描述句。",
|
||||
visible=1,
|
||||
readonly=0,
|
||||
)
|
||||
seed_column_metadata_batch(
|
||||
cursor,
|
||||
table_name="expense_items",
|
||||
columns=_EXPENSE_ITEMS_COLUMNS,
|
||||
valid_column_names=[str(c["column_name"]) for c in _EXPENSE_ITEMS_COLUMNS],
|
||||
)
|
||||
|
||||
|
||||
def _init_report_drafts_metadata(cursor) -> None:
|
||||
cursor.execute(_REPORT_DRAFTS_DDL)
|
||||
cursor.execute(_REPORT_DRAFTS_INDEX)
|
||||
upsert_table_metadata(
|
||||
cursor,
|
||||
table_name="report_drafts",
|
||||
display_name="初稿记录",
|
||||
description="每次生成的初稿记录：指标对比、素材要点与文件路径。",
|
||||
grid_help="Word 文件在 output 目录可下载；HTML 预览在侧栏查看。",
|
||||
visible=1,
|
||||
readonly=1,
|
||||
default_sort_json='[{"column":"id","direction":"desc"}]',
|
||||
default_visible_columns_json='["id","project_no","project_name","created_at"]',
|
||||
)
|
||||
seed_column_metadata_batch(
|
||||
cursor,
|
||||
table_name="report_drafts",
|
||||
columns=_REPORT_DRAFTS_COLUMNS,
|
||||
valid_column_names=[str(c["column_name"]) for c in _REPORT_DRAFTS_COLUMNS],
|
||||
)
|
||||
|
||||
|
||||
def init_db() -> dict[str, int]:
|
||||
"""幂等创建/迁移本地 SQLite 与数据管理元数据。"""
|
||||
conn = get_conn()
|
||||
try:
|
||||
cur = conn.cursor()
|
||||
init_display_metadata(cur)
|
||||
_init_closing_projects_metadata(cur)
|
||||
_init_achievements_metadata(cur)
|
||||
_init_expense_items_metadata(cur)
|
||||
_init_report_drafts_metadata(cur)
|
||||
conn.commit()
|
||||
return {}
|
||||
finally:
|
||||
conn.close()
|
||||
324
scripts/db/display_metadata.py
Normal file
324
scripts/db/display_metadata.py
Normal file
@@ -0,0 +1,324 @@
|
||||
"""匠厂数据管理展示元数据（_jiangchang_tables / _jiangchang_columns）。
|
||||
|
||||
SQLite 无原生表/字段 COMMENT；中文展示名称通过这两张元数据表提供给宿主「数据管理」页面。
|
||||
字段在界面上的顺序由 CREATE TABLE / PRAGMA table_info(cid) 决定，**不**使用 display_order 排序。
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Iterable
|
||||
|
||||
# 宿主会隐藏这些表，不作为业务表展示（见 jiangchang electron/data-management/types.ts）
|
||||
INTERNAL_METADATA_TABLES = frozenset({"_jiangchang_tables", "_jiangchang_columns"})
|
||||
LEGACY_METADATA_TABLES = frozenset({"_schema_meta"})
|
||||
METADATA_TABLES = INTERNAL_METADATA_TABLES | LEGACY_METADATA_TABLES
|
||||
|
||||
DATETIME_UNIX_SECONDS = "datetime_unix_seconds"
|
||||
STANDARD_TIMESTAMP_COLUMNS = frozenset({"created_at", "updated_at"})
|
||||
|
||||
_JIANGCHANG_TABLES_DDL = """
|
||||
CREATE TABLE IF NOT EXISTS _jiangchang_tables (
|
||||
table_name TEXT PRIMARY KEY,
|
||||
display_name TEXT NOT NULL,
|
||||
description TEXT,
|
||||
grid_help TEXT,
|
||||
sort_order INTEGER,
|
||||
visible INTEGER NOT NULL DEFAULT 1,
|
||||
readonly INTEGER NOT NULL DEFAULT 0,
|
||||
default_sort_json TEXT,
|
||||
default_visible_columns_json TEXT
|
||||
)
|
||||
"""
|
||||
|
||||
_JIANGCHANG_COLUMNS_DDL = """
|
||||
CREATE TABLE IF NOT EXISTS _jiangchang_columns (
|
||||
table_name TEXT NOT NULL,
|
||||
column_name TEXT NOT NULL,
|
||||
display_name TEXT NOT NULL,
|
||||
description TEXT,
|
||||
grid_help TEXT,
|
||||
display_order INTEGER,
|
||||
visible INTEGER NOT NULL DEFAULT 1,
|
||||
searchable INTEGER NOT NULL DEFAULT 1,
|
||||
editable INTEGER NOT NULL DEFAULT 1,
|
||||
display_type TEXT,
|
||||
options_json TEXT,
|
||||
PRIMARY KEY (table_name, column_name)
|
||||
)
|
||||
"""
|
||||
|
||||
def _pragma_column_names(cursor, table_name: str) -> set[str]:
|
||||
cursor.execute(f"PRAGMA table_info({table_name!r})")
|
||||
return {str(row[1]) for row in cursor.fetchall()}
|
||||
|
||||
|
||||
def _ensure_jiangchang_tables_columns(cursor) -> None:
|
||||
"""旧库补列：CREATE IF NOT EXISTS 不会给已有表加新字段。"""
|
||||
cols = _pragma_column_names(cursor, "_jiangchang_tables")
|
||||
if "default_sort_json" not in cols:
|
||||
cursor.execute("ALTER TABLE _jiangchang_tables ADD COLUMN default_sort_json TEXT")
|
||||
if "default_visible_columns_json" not in cols:
|
||||
cursor.execute(
|
||||
"ALTER TABLE _jiangchang_tables ADD COLUMN default_visible_columns_json TEXT"
|
||||
)
|
||||
if "grid_help" not in cols:
|
||||
cursor.execute("ALTER TABLE _jiangchang_tables ADD COLUMN grid_help TEXT")
|
||||
|
||||
|
||||
def _ensure_jiangchang_columns_columns(cursor) -> None:
|
||||
cols = _pragma_column_names(cursor, "_jiangchang_columns")
|
||||
if "grid_help" not in cols:
|
||||
cursor.execute("ALTER TABLE _jiangchang_columns ADD COLUMN grid_help TEXT")
|
||||
|
||||
|
||||
def init_display_metadata_tables(cursor) -> None:
|
||||
cursor.execute(_JIANGCHANG_TABLES_DDL)
|
||||
cursor.execute(_JIANGCHANG_COLUMNS_DDL)
|
||||
_ensure_jiangchang_tables_columns(cursor)
|
||||
_ensure_jiangchang_columns_columns(cursor)
|
||||
|
||||
|
||||
def upsert_table_metadata(
|
||||
cursor,
|
||||
*,
|
||||
table_name: str,
|
||||
display_name: str,
|
||||
description: str | None = None,
|
||||
grid_help: str | None = None,
|
||||
visible: int = 1,
|
||||
readonly: int = 0,
|
||||
default_sort_json: str | None = None,
|
||||
default_visible_columns_json: str | None = None,
|
||||
) -> None:
|
||||
"""写入表级元数据。
|
||||
|
||||
default_sort_json: 宿主数据管理默认排序，JSON 数组，例如
|
||||
'[{"column":"sent_at","direction":"desc"},{"column":"id","direction":"desc"}]'
|
||||
为空则宿主回退到 updated_at → created_at → 主键。
|
||||
|
||||
default_visible_columns_json: 宿主数据管理默认展示列，JSON 字符串数组，例如
|
||||
'["stat_type","period","stage"]'
|
||||
为空则全显；用户改过「列」后以本机偏好为准（软默认，区别于 visible=0 硬隐藏）。
|
||||
|
||||
grid_help: 数据管理表格上方说明；空则不出横幅。与表单用的 description 独立，禁止互拷。
|
||||
"""
|
||||
cursor.execute(
|
||||
"""
|
||||
INSERT INTO _jiangchang_tables (
|
||||
table_name, display_name, description, grid_help, visible, readonly,
|
||||
default_sort_json, default_visible_columns_json
|
||||
)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
|
||||
ON CONFLICT(table_name) DO UPDATE SET
|
||||
display_name = excluded.display_name,
|
||||
description = excluded.description,
|
||||
grid_help = excluded.grid_help,
|
||||
visible = excluded.visible,
|
||||
readonly = excluded.readonly,
|
||||
default_sort_json = excluded.default_sort_json,
|
||||
default_visible_columns_json = excluded.default_visible_columns_json
|
||||
""",
|
||||
(
|
||||
table_name,
|
||||
display_name,
|
||||
description,
|
||||
grid_help,
|
||||
visible,
|
||||
readonly,
|
||||
default_sort_json,
|
||||
default_visible_columns_json,
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
def upsert_column_metadata(
|
||||
cursor,
|
||||
*,
|
||||
table_name: str,
|
||||
column_name: str,
|
||||
display_name: str,
|
||||
description: str | None = None,
|
||||
grid_help: str | None = None,
|
||||
visible: int = 1,
|
||||
searchable: int = 1,
|
||||
editable: int = 1,
|
||||
display_type: str | None = None,
|
||||
options_json: str | None = None,
|
||||
) -> None:
|
||||
# display_order 保留为 NULL：宿主按 PRAGMA table_info cid 展示字段，不读 display_order。
|
||||
# grid_help: 表头「?」；空则不出。与表单用的 description 独立，禁止互拷。
|
||||
cursor.execute(
|
||||
"""
|
||||
INSERT INTO _jiangchang_columns (
|
||||
table_name, column_name, display_name, description, grid_help,
|
||||
display_order, visible, searchable, editable, display_type, options_json
|
||||
)
|
||||
VALUES (?, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?)
|
||||
ON CONFLICT(table_name, column_name) DO UPDATE SET
|
||||
display_name = excluded.display_name,
|
||||
description = excluded.description,
|
||||
grid_help = excluded.grid_help,
|
||||
display_order = NULL,
|
||||
visible = excluded.visible,
|
||||
searchable = excluded.searchable,
|
||||
editable = excluded.editable,
|
||||
display_type = excluded.display_type,
|
||||
options_json = excluded.options_json
|
||||
""",
|
||||
(
|
||||
table_name,
|
||||
column_name,
|
||||
display_name,
|
||||
description,
|
||||
grid_help,
|
||||
visible,
|
||||
searchable,
|
||||
editable,
|
||||
display_type,
|
||||
options_json,
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
def seed_column_metadata_batch(
|
||||
cursor,
|
||||
*,
|
||||
table_name: str,
|
||||
columns: Iterable[dict[str, object]],
|
||||
valid_column_names: Iterable[str] | None = None,
|
||||
) -> None:
|
||||
"""批量 upsert 字段元数据；传入 valid_column_names 时会在 upsert 后清理陈旧字段元数据。"""
|
||||
for column in columns:
|
||||
upsert_column_metadata(
|
||||
cursor,
|
||||
table_name=table_name,
|
||||
column_name=str(column["column_name"]),
|
||||
display_name=str(column["display_name"]),
|
||||
description=str(column["description"]) if column.get("description") else None,
|
||||
grid_help=str(column["grid_help"]) if column.get("grid_help") else None,
|
||||
visible=int(column.get("visible", 1)),
|
||||
searchable=int(column.get("searchable", 1)),
|
||||
editable=int(column.get("editable", 1)),
|
||||
display_type=str(column["display_type"]) if column.get("display_type") else None,
|
||||
options_json=str(column["options_json"]) if column.get("options_json") else None,
|
||||
)
|
||||
if valid_column_names is not None:
|
||||
prune_stale_column_metadata(cursor, table_name, valid_column_names)
|
||||
|
||||
|
||||
def prune_stale_column_metadata(cursor, table_name: str, valid_column_names: Iterable[str]) -> None:
|
||||
"""删除表中已不存在物理字段的元数据行（幂等初始化后不得残留旧字段）。"""
|
||||
valid = set(valid_column_names)
|
||||
cursor.execute(
|
||||
"SELECT column_name FROM _jiangchang_columns WHERE table_name = ?",
|
||||
(table_name,),
|
||||
)
|
||||
for (column_name,) in cursor.fetchall():
|
||||
if str(column_name) not in valid:
|
||||
cursor.execute(
|
||||
"DELETE FROM _jiangchang_columns WHERE table_name = ? AND column_name = ?",
|
||||
(table_name, column_name),
|
||||
)
|
||||
|
||||
|
||||
def get_table_readonly(cursor, table_name: str) -> int | None:
|
||||
cursor.execute(
|
||||
"SELECT readonly FROM _jiangchang_tables WHERE table_name = ?",
|
||||
(table_name,),
|
||||
)
|
||||
row = cursor.fetchone()
|
||||
if not row:
|
||||
return None
|
||||
return int(row[0] or 0)
|
||||
|
||||
|
||||
def get_column_editable(cursor, table_name: str, column_name: str) -> int | None:
|
||||
cursor.execute(
|
||||
"""
|
||||
SELECT editable FROM _jiangchang_columns
|
||||
WHERE table_name = ? AND column_name = ?
|
||||
""",
|
||||
(table_name, column_name),
|
||||
)
|
||||
row = cursor.fetchone()
|
||||
if not row:
|
||||
return None
|
||||
return int(row[0] or 0)
|
||||
|
||||
|
||||
def list_editable_business_columns(cursor, table_name: str) -> list[str]:
|
||||
"""返回 editable=1 的业务字段名（不含宿主侧主键/generated 等二次过滤）。"""
|
||||
physical = list_physical_column_names(cursor, table_name)
|
||||
cursor.execute(
|
||||
"""
|
||||
SELECT column_name, editable
|
||||
FROM _jiangchang_columns
|
||||
WHERE table_name = ?
|
||||
""",
|
||||
(table_name,),
|
||||
)
|
||||
editable_set = {
|
||||
str(column_name)
|
||||
for column_name, editable in cursor.fetchall()
|
||||
if editable is not None and int(editable) == 1
|
||||
}
|
||||
return [name for name in physical if name in editable_set]
|
||||
|
||||
|
||||
def table_allows_manual_create(cursor, table_name: str) -> bool:
|
||||
"""表级 readonly=0 且至少有一个 editable=1 字段时，宿主才应提供空白新增表单。"""
|
||||
readonly = get_table_readonly(cursor, table_name)
|
||||
if readonly is None or int(readonly) != 0:
|
||||
return False
|
||||
return bool(list_editable_business_columns(cursor, table_name))
|
||||
|
||||
|
||||
def init_display_metadata(cursor) -> None:
|
||||
init_display_metadata_tables(cursor)
|
||||
|
||||
|
||||
def drop_deprecated_user_table(
|
||||
cursor,
|
||||
table_name: str,
|
||||
*,
|
||||
triggers: Iterable[str] | None = None,
|
||||
) -> None:
|
||||
"""永久退役用户可见表：删 trigger、DROP 物理表、清理展示元数据（幂等）。
|
||||
|
||||
用于废弃 task_logs 等旧表。禁止只删元数据而保留物理表。
|
||||
见 references/SCHEMA.md「表增删改与退役」。
|
||||
"""
|
||||
for trigger_name in triggers or ():
|
||||
cursor.execute(f"DROP TRIGGER IF EXISTS {trigger_name}")
|
||||
default_updated_at = f"{table_name}_set_updated_at"
|
||||
cursor.execute(f"DROP TRIGGER IF EXISTS {default_updated_at}")
|
||||
cursor.execute(f"DROP TABLE IF EXISTS {_quote_identifier(table_name)}")
|
||||
cursor.execute(
|
||||
"DELETE FROM _jiangchang_columns WHERE table_name = ?",
|
||||
(table_name,),
|
||||
)
|
||||
cursor.execute(
|
||||
"DELETE FROM _jiangchang_tables WHERE table_name = ?",
|
||||
(table_name,),
|
||||
)
|
||||
|
||||
|
||||
def iter_user_tables(cursor) -> Iterable[str]:
|
||||
cursor.execute(
|
||||
"SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name"
|
||||
)
|
||||
for (name,) in cursor.fetchall():
|
||||
if name in METADATA_TABLES:
|
||||
continue
|
||||
yield str(name)
|
||||
|
||||
|
||||
def _quote_identifier(name: str) -> str:
|
||||
return '"' + name.replace('"', '""') + '"'
|
||||
|
||||
|
||||
def list_physical_column_names(cursor, table_name: str) -> list[str]:
|
||||
cursor.execute(f"PRAGMA table_info({_quote_identifier(table_name)})")
|
||||
rows = cursor.fetchall()
|
||||
rows.sort(key=lambda row: int(row[0]))
|
||||
return [str(row[1]) for row in rows]
|
||||
592
scripts/db/display_metadata_validator.py
Normal file
592
scripts/db/display_metadata_validator.py
Normal file
@@ -0,0 +1,592 @@
|
||||
"""数据管理展示元数据校验（模板开发自检，不依赖宿主）。"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import sqlite3
|
||||
from dataclasses import dataclass, field
|
||||
|
||||
from db.display_metadata import (
|
||||
DATETIME_UNIX_SECONDS,
|
||||
METADATA_TABLES,
|
||||
STANDARD_TIMESTAMP_COLUMNS,
|
||||
iter_user_tables,
|
||||
list_editable_business_columns,
|
||||
list_physical_column_names,
|
||||
table_allows_manual_create,
|
||||
)
|
||||
from db.timestamp_columns import has_updated_at_trigger
|
||||
from util.constants import SKILL_SLUG
|
||||
from util.slug_naming import LEGACY_EXEMPT_SLUGS, validate_slug_semantics
|
||||
|
||||
_TEMPLATE_PLACEHOLDER_SLUGS = frozenset({"your-skill-slug", "your_skill_slug"})
|
||||
_ENGLISH_PLACEHOLDER_NAME_PATTERNS = (
|
||||
re.compile(r"^my\s+skill$", re.I),
|
||||
re.compile(r"^your[-_\s]?skill", re.I),
|
||||
re.compile(r"^skill[-_\s]?template$", re.I),
|
||||
re.compile(r"^[a-z0-9_-]+$"),
|
||||
)
|
||||
_KEBAB_SLUG = re.compile(r"^[a-z0-9]+(?:-[a-z0-9]+)*$")
|
||||
_CJK_RE = re.compile(r"[\u4e00-\u9fff]")
|
||||
_FK_DDL_PATTERN = re.compile(r"\bFOREIGN\s+KEY\b|\bREFERENCES\b", re.I)
|
||||
|
||||
|
||||
@dataclass
|
||||
class ValidationReport:
|
||||
errors: list[str] = field(default_factory=list)
|
||||
warnings: list[str] = field(default_factory=list)
|
||||
|
||||
@property
|
||||
def ok(self) -> bool:
|
||||
return not self.errors
|
||||
|
||||
|
||||
def _has_cjk(text: str) -> bool:
|
||||
return bool(_CJK_RE.search(text))
|
||||
|
||||
|
||||
def _looks_like_raw_physical_name(display_name: str, physical_name: str) -> bool:
|
||||
if not display_name.strip():
|
||||
return True
|
||||
if display_name.strip().lower() == physical_name.strip().lower():
|
||||
return True
|
||||
compact = display_name.replace(" ", "").replace("_", "").lower()
|
||||
if compact == physical_name.replace("_", "").lower():
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def _parse_frontmatter_field(text: str, field_name: str) -> str:
|
||||
parts = text.split("---", 2)
|
||||
if len(parts) < 2:
|
||||
return ""
|
||||
for line in parts[1].splitlines():
|
||||
match = re.match(rf"^{re.escape(field_name)}:\s*(.+)\s*$", line.strip())
|
||||
if match:
|
||||
return match.group(1).strip().strip("\"'")
|
||||
return ""
|
||||
|
||||
|
||||
def _parse_openclaw_slug(text: str) -> str:
|
||||
parts = text.split("---", 2)
|
||||
if len(parts) < 2:
|
||||
return ""
|
||||
lines = parts[1].splitlines()
|
||||
for index, line in enumerate(lines):
|
||||
if re.match(r"^\s+openclaw:\s*$", line):
|
||||
for inner in lines[index + 1 :]:
|
||||
if inner.strip() and inner[0] not in (" ", "\t"):
|
||||
break
|
||||
match = re.match(r"^(\s+)slug:\s*(.+)\s*$", inner)
|
||||
if match:
|
||||
return match.group(2).strip().strip("\"'")
|
||||
return ""
|
||||
|
||||
|
||||
def parse_skill_frontmatter(skill_root: str) -> dict[str, str]:
|
||||
path = os.path.join(skill_root, "SKILL.md")
|
||||
with open(path, encoding="utf-8") as f:
|
||||
text = f.read()
|
||||
return {
|
||||
"name": _parse_frontmatter_field(text, "name"),
|
||||
"slug": _parse_openclaw_slug(text),
|
||||
}
|
||||
|
||||
|
||||
def validate_skill_frontmatter(skill_root: str, *, allow_template_placeholders: bool = True) -> ValidationReport:
|
||||
report = ValidationReport()
|
||||
data = parse_skill_frontmatter(skill_root)
|
||||
name = str(data.get("name") or "").strip()
|
||||
slug = str(data.get("slug") or "").strip()
|
||||
|
||||
if not name:
|
||||
report.errors.append("SKILL.md frontmatter.name 缺失")
|
||||
elif not _has_cjk(name):
|
||||
if allow_template_placeholders and slug in _TEMPLATE_PLACEHOLDER_SLUGS:
|
||||
report.warnings.append("SKILL.md frontmatter.name 建议使用清晰的中文业务名称（模板占位可暂保留）")
|
||||
else:
|
||||
report.errors.append("SKILL.md frontmatter.name 应使用用户可见的中文业务名称")
|
||||
else:
|
||||
for pattern in _ENGLISH_PLACEHOLDER_NAME_PATTERNS:
|
||||
if pattern.fullmatch(name):
|
||||
if allow_template_placeholders and slug in _TEMPLATE_PLACEHOLDER_SLUGS:
|
||||
report.warnings.append(f"SKILL.md frontmatter.name 仍为占位风格：{name!r}")
|
||||
else:
|
||||
report.errors.append(f"SKILL.md frontmatter.name 不应为英文占位名：{name!r}")
|
||||
break
|
||||
|
||||
if not slug:
|
||||
report.errors.append("SKILL.md metadata.openclaw.slug 缺失")
|
||||
elif not _KEBAB_SLUG.fullmatch(slug):
|
||||
report.errors.append(f"metadata.openclaw.slug 必须为 kebab-case：{slug!r}")
|
||||
elif slug in _TEMPLATE_PLACEHOLDER_SLUGS and not allow_template_placeholders:
|
||||
report.errors.append(f"metadata.openclaw.slug 仍为模板占位：{slug!r}")
|
||||
|
||||
constants_slug = SKILL_SLUG.strip()
|
||||
if slug and constants_slug and slug != constants_slug:
|
||||
report.warnings.append(
|
||||
f"SKILL.md slug ({slug!r}) 与 util.constants.SKILL_SLUG ({constants_slug!r}) 不一致"
|
||||
)
|
||||
|
||||
if slug and slug not in LEGACY_EXEMPT_SLUGS and _KEBAB_SLUG.fullmatch(slug):
|
||||
naming_errors, naming_warnings = validate_slug_semantics(
|
||||
slug,
|
||||
strict=not allow_template_placeholders,
|
||||
)
|
||||
report.errors.extend(naming_errors)
|
||||
report.warnings.extend(naming_warnings)
|
||||
|
||||
return report
|
||||
|
||||
|
||||
def _quote_identifier(name: str) -> str:
|
||||
return '"' + name.replace('"', '""') + '"'
|
||||
|
||||
|
||||
def _table_column_info(cursor, table_name: str) -> dict[str, dict[str, object]]:
|
||||
cursor.execute(f"PRAGMA table_info({_quote_identifier(table_name)})")
|
||||
info: dict[str, dict[str, object]] = {}
|
||||
for row in cursor.fetchall():
|
||||
info[str(row[1])] = {
|
||||
"cid": int(row[0]),
|
||||
"name": str(row[1]),
|
||||
"type": str(row[2] or ""),
|
||||
"notnull": int(row[3] or 0),
|
||||
"dflt_value": row[4],
|
||||
"pk": int(row[5] or 0),
|
||||
}
|
||||
return info
|
||||
|
||||
|
||||
def _table_column_xinfo(cursor, table_name: str) -> dict[str, dict[str, object]]:
|
||||
"""PRAGMA table_xinfo 可识别 generated/hidden 字段（SQLite 3.31+）。"""
|
||||
cursor.execute(f"PRAGMA table_xinfo({_quote_identifier(table_name)})")
|
||||
info: dict[str, dict[str, object]] = {}
|
||||
for row in cursor.fetchall():
|
||||
hidden = int(row[6] or 0) if len(row) > 6 else 0
|
||||
info[str(row[1])] = {
|
||||
"cid": int(row[0]),
|
||||
"name": str(row[1]),
|
||||
"type": str(row[2] or ""),
|
||||
"notnull": int(row[3] or 0),
|
||||
"dflt_value": row[4],
|
||||
"pk": int(row[5] or 0),
|
||||
"hidden": hidden,
|
||||
}
|
||||
return info
|
||||
|
||||
|
||||
def _is_generated_column(xinfo: dict[str, object]) -> bool:
|
||||
hidden = int(xinfo.get("hidden") or 0)
|
||||
return hidden in (2, 3)
|
||||
|
||||
|
||||
def _is_blob_column(column_info: dict[str, object]) -> bool:
|
||||
return "BLOB" in str(column_info.get("type") or "").upper()
|
||||
|
||||
|
||||
def _default_uses_unixepoch(default_value: object) -> bool:
|
||||
if default_value is None:
|
||||
return False
|
||||
text = str(default_value).strip().lower()
|
||||
return "unixepoch" in text
|
||||
|
||||
|
||||
def validate_options_json(options_json: str | None) -> tuple[list[str], list[str]]:
|
||||
"""校验 options_json：静态枚举数组，或 lookup 对象。"""
|
||||
errors: list[str] = []
|
||||
warnings: list[str] = []
|
||||
if options_json is None or str(options_json).strip() == "":
|
||||
return errors, warnings
|
||||
try:
|
||||
parsed = json.loads(str(options_json))
|
||||
except json.JSONDecodeError as exc:
|
||||
errors.append(f"options_json 不是合法 JSON：{exc}")
|
||||
return errors, warnings
|
||||
|
||||
if isinstance(parsed, dict):
|
||||
for key in ("ref_table", "value_column", "label_column"):
|
||||
if not str(parsed.get(key) or "").strip():
|
||||
errors.append(f"options_json lookup 必须包含非空 {key}")
|
||||
ident = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_]*$")
|
||||
for key in ("ref_table", "value_column", "label_column", "filter_column"):
|
||||
raw = parsed.get(key)
|
||||
if raw is None or raw == "":
|
||||
continue
|
||||
if not ident.match(str(raw)):
|
||||
errors.append(f"options_json.{key} 必须是安全标识符，当前为 {raw!r}")
|
||||
if parsed.get("filter_column") not in (None, "") and "filter_value" not in parsed:
|
||||
warnings.append("options_json lookup 声明了 filter_column 但未提供 filter_value")
|
||||
if "multiple" in parsed and not isinstance(parsed.get("multiple"), bool):
|
||||
errors.append("options_json lookup.multiple 必须是布尔值")
|
||||
return errors, warnings
|
||||
|
||||
if not isinstance(parsed, list):
|
||||
errors.append("options_json 必须是 JSON 数组（静态枚举）或对象（lookup）")
|
||||
return errors, warnings
|
||||
for index, item in enumerate(parsed):
|
||||
if not isinstance(item, dict):
|
||||
errors.append(f"options_json[{index}] 必须是对象")
|
||||
continue
|
||||
if "value" not in item or "label" not in item:
|
||||
errors.append(f"options_json[{index}] 必须包含 value 与 label")
|
||||
return errors, warnings
|
||||
|
||||
|
||||
def validate_filter_search_metadata(
|
||||
cursor,
|
||||
table_name: str,
|
||||
) -> tuple[list[str], list[str]]:
|
||||
"""对可见但未开启 searchable 的枚举 / boolean 列给出软建议。"""
|
||||
warnings: list[str] = []
|
||||
cursor.execute(
|
||||
"""
|
||||
SELECT column_name, visible, searchable, display_type, options_json
|
||||
FROM _jiangchang_columns
|
||||
WHERE table_name = ?
|
||||
""",
|
||||
(table_name,),
|
||||
)
|
||||
for column_name, visible, searchable, display_type, options_json in cursor.fetchall():
|
||||
if visible is not None and int(visible) == 0:
|
||||
continue
|
||||
if searchable is not None and int(searchable) != 0:
|
||||
continue
|
||||
|
||||
display_type_norm = str(display_type or "").strip()
|
||||
is_boolean = display_type_norm == "boolean"
|
||||
|
||||
has_enum = False
|
||||
if options_json is not None and str(options_json).strip():
|
||||
opt_errors, _ = validate_options_json(options_json)
|
||||
if not opt_errors:
|
||||
try:
|
||||
parsed = json.loads(str(options_json))
|
||||
except json.JSONDecodeError:
|
||||
parsed = None
|
||||
has_enum = isinstance(parsed, list) and len(parsed) > 0
|
||||
|
||||
if not has_enum and not is_boolean:
|
||||
continue
|
||||
|
||||
warnings.append(
|
||||
f"{table_name}.{column_name}: 枚举/状态类列建议 searchable=1，"
|
||||
"以便宿主列筛选与按中文 label 全局搜索（见 references/SCHEMA.md）"
|
||||
)
|
||||
|
||||
return [], warnings
|
||||
|
||||
|
||||
def validate_column_permissions(
|
||||
cursor,
|
||||
table_name: str,
|
||||
*,
|
||||
physical_columns: list[str] | None = None,
|
||||
) -> tuple[list[str], list[str]]:
|
||||
"""校验常见系统字段 editable=0，并识别技术上可写但不适合手工新增的表。"""
|
||||
errors: list[str] = []
|
||||
warnings: list[str] = []
|
||||
ordered = physical_columns or list_physical_column_names(cursor, table_name)
|
||||
column_info = _table_column_info(cursor, table_name)
|
||||
column_xinfo = _table_column_xinfo(cursor, table_name)
|
||||
|
||||
cursor.execute(
|
||||
"""
|
||||
SELECT column_name, editable, options_json
|
||||
FROM _jiangchang_columns
|
||||
WHERE table_name = ?
|
||||
""",
|
||||
(table_name,),
|
||||
)
|
||||
meta_by_column = {
|
||||
str(row[0]): {"editable": row[1], "options_json": row[2]}
|
||||
for row in cursor.fetchall()
|
||||
}
|
||||
|
||||
for column_name, meta in meta_by_column.items():
|
||||
physical = column_info.get(column_name) or {}
|
||||
xinfo = column_xinfo.get(column_name) or physical
|
||||
if not physical and column_name not in column_xinfo:
|
||||
continue
|
||||
|
||||
pk = int(physical.get("pk") or xinfo.get("pk") or 0)
|
||||
editable = meta["editable"]
|
||||
if pk and editable is not None and int(editable) != 0:
|
||||
errors.append(f"{table_name}.{column_name} 是主键，editable 应为 0")
|
||||
|
||||
if column_name == "id" and editable is not None and int(editable) != 0:
|
||||
errors.append(f"{table_name}.id 的 editable 应为 0（自增主键）")
|
||||
|
||||
if _is_generated_column(xinfo) and editable is not None and int(editable) != 0:
|
||||
errors.append(f"{table_name}.{column_name} 是 generated 字段，editable 应为 0")
|
||||
|
||||
if _is_blob_column(physical or xinfo) and editable is not None and int(editable) != 0:
|
||||
errors.append(f"{table_name}.{column_name} 是 BLOB 字段，editable 应为 0")
|
||||
|
||||
opt_errors, _ = validate_options_json(meta.get("options_json"))
|
||||
for item in opt_errors:
|
||||
errors.append(f"{table_name}.{column_name}: {item}")
|
||||
|
||||
cursor.execute(
|
||||
"SELECT readonly FROM _jiangchang_tables WHERE table_name = ?",
|
||||
(table_name,),
|
||||
)
|
||||
readonly_row = cursor.fetchone()
|
||||
readonly = int(readonly_row[0]) if readonly_row else None
|
||||
editable_columns = list_editable_business_columns(cursor, table_name)
|
||||
if readonly == 0 and not editable_columns:
|
||||
warnings.append(
|
||||
f"{table_name}: 表级 readonly=0 但所有字段 editable=0，"
|
||||
"宿主不应打开空白新增表单；数据应由技能业务流程产生"
|
||||
)
|
||||
if readonly == 1 and editable_columns:
|
||||
warnings.append(
|
||||
f"{table_name}: 表级 readonly=1 但存在 editable=1 字段，"
|
||||
"宿主应以表级只读为准"
|
||||
)
|
||||
|
||||
return errors, warnings
|
||||
|
||||
|
||||
def _expected_timestamp_display_name(column_name: str) -> str:
|
||||
if column_name == "created_at":
|
||||
return "创建时间"
|
||||
if column_name == "updated_at":
|
||||
return "更新时间"
|
||||
return ""
|
||||
|
||||
|
||||
def validate_standard_timestamp_columns(
|
||||
cursor,
|
||||
table_name: str,
|
||||
*,
|
||||
physical_columns: list[str] | None = None,
|
||||
) -> tuple[list[str], list[str]]:
|
||||
errors: list[str] = []
|
||||
warnings: list[str] = []
|
||||
ordered = physical_columns or list_physical_column_names(cursor, table_name)
|
||||
column_info = _table_column_info(cursor, table_name)
|
||||
|
||||
for column_name in STANDARD_TIMESTAMP_COLUMNS:
|
||||
if column_name not in ordered:
|
||||
continue
|
||||
|
||||
physical = column_info.get(column_name)
|
||||
if not physical:
|
||||
errors.append(f"{table_name}.{column_name} 缺少物理字段定义")
|
||||
continue
|
||||
|
||||
if "INT" not in str(physical["type"]).upper():
|
||||
errors.append(
|
||||
f"{table_name}.{column_name} 字段类型应为 INTEGER（Unix 秒级时间戳），当前为 {physical['type']!r}"
|
||||
)
|
||||
|
||||
if column_name == "created_at" and not _default_uses_unixepoch(physical["dflt_value"]):
|
||||
errors.append(
|
||||
f"{table_name}.created_at 应设置数据库默认值 DEFAULT (unixepoch())，当前默认值为 {physical['dflt_value']!r}"
|
||||
)
|
||||
if column_name == "updated_at" and not _default_uses_unixepoch(physical["dflt_value"]):
|
||||
errors.append(
|
||||
f"{table_name}.updated_at 应设置数据库初始默认值 DEFAULT (unixepoch())，当前默认值为 {physical['dflt_value']!r}"
|
||||
)
|
||||
|
||||
cursor.execute(
|
||||
"""
|
||||
SELECT display_name, display_type, editable, searchable, display_order
|
||||
FROM _jiangchang_columns
|
||||
WHERE table_name = ? AND column_name = ?
|
||||
""",
|
||||
(table_name, column_name),
|
||||
)
|
||||
meta_row = cursor.fetchone()
|
||||
if not meta_row:
|
||||
errors.append(f"{table_name}.{column_name} 缺少 _jiangchang_columns 元数据")
|
||||
continue
|
||||
|
||||
display_name, display_type, editable, searchable, display_order = meta_row
|
||||
expected_name = _expected_timestamp_display_name(column_name)
|
||||
if str(display_name or "").strip() != expected_name:
|
||||
errors.append(
|
||||
f"{table_name}.{column_name} 的 display_name 应为 {expected_name!r}，当前为 {display_name!r}"
|
||||
)
|
||||
if str(display_type or "").strip() != DATETIME_UNIX_SECONDS:
|
||||
errors.append(
|
||||
f"{table_name}.{column_name} 的 display_type 应为 {DATETIME_UNIX_SECONDS!r}，当前为 {display_type!r}"
|
||||
)
|
||||
if editable is None or int(editable) != 0:
|
||||
errors.append(f"{table_name}.{column_name} 的 editable 应为 0（系统时间字段不可编辑）")
|
||||
if display_order is not None:
|
||||
errors.append(f"{table_name}.{column_name} 的 display_order 应为 NULL")
|
||||
if searchable is not None and int(searchable) != 0:
|
||||
warnings.append(f"{table_name}.{column_name} 的时间字段通常不必开启 searchable")
|
||||
|
||||
if "created_at" in ordered and "updated_at" in ordered:
|
||||
if ordered.index("updated_at") < ordered.index("created_at"):
|
||||
warnings.append(f"{table_name}: updated_at 不应出现在 created_at 之前")
|
||||
|
||||
if "updated_at" in ordered and not has_updated_at_trigger(cursor, table_name):
|
||||
errors.append(
|
||||
f"{table_name}.updated_at 缺少自动维护 trigger（期望 {table_name}_set_updated_at）"
|
||||
)
|
||||
|
||||
return errors, warnings
|
||||
|
||||
|
||||
def column_order_warnings(table_name: str, ordered_names: list[str]) -> list[str]:
|
||||
warnings: list[str] = []
|
||||
if "id" in ordered_names and ordered_names.index("id") != 0:
|
||||
warnings.append(f"{table_name}: 字段 id 通常应定义在 CREATE TABLE 的第一列")
|
||||
if "created_at" in ordered_names:
|
||||
idx = ordered_names.index("created_at")
|
||||
trailing = ordered_names[idx + 1 :]
|
||||
if trailing and trailing != ["updated_at"]:
|
||||
warnings.append(
|
||||
f"{table_name}: created_at 之后通常只应跟 updated_at，不应再放置其他业务字段"
|
||||
)
|
||||
if "updated_at" in ordered_names and "created_at" in ordered_names:
|
||||
if ordered_names.index("updated_at") < ordered_names.index("created_at"):
|
||||
warnings.append(f"{table_name}: updated_at 不应出现在 created_at 之前")
|
||||
return warnings
|
||||
|
||||
|
||||
def _table_exists(cursor, table_name: str) -> bool:
|
||||
cursor.execute(
|
||||
"SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ? LIMIT 1",
|
||||
(table_name,),
|
||||
)
|
||||
return cursor.fetchone() is not None
|
||||
|
||||
|
||||
def validate_no_sqlite_foreign_keys(cursor) -> tuple[list[str], list[str]]:
|
||||
"""业务表 DDL 不得含 FOREIGN KEY / REFERENCES（关联走 repository/service）。"""
|
||||
errors: list[str] = []
|
||||
cursor.execute(
|
||||
"""
|
||||
SELECT name, sql FROM sqlite_master
|
||||
WHERE type = 'table' AND name NOT LIKE 'sqlite_%'
|
||||
"""
|
||||
)
|
||||
for table_name, sql in cursor.fetchall():
|
||||
if table_name in METADATA_TABLES:
|
||||
continue
|
||||
ddl = str(sql or "")
|
||||
if ddl and _FK_DDL_PATTERN.search(ddl):
|
||||
errors.append(
|
||||
f"业务表 {table_name!r} 的 DDL 含 SQLite FOREIGN KEY/REFERENCES；"
|
||||
"请改为业务 id 列 + repository/service 逻辑关联（见 references/SCHEMA.md）"
|
||||
)
|
||||
return errors, []
|
||||
|
||||
|
||||
def validate_display_metadata(conn: sqlite3.Connection, *, check_column_order: bool = True) -> ValidationReport:
|
||||
report = ValidationReport()
|
||||
cur = conn.cursor()
|
||||
|
||||
has_tables_meta = _table_exists(cur, "_jiangchang_tables")
|
||||
has_columns_meta = _table_exists(cur, "_jiangchang_columns")
|
||||
if not has_tables_meta:
|
||||
report.errors.append("缺少数据管理元数据表 _jiangchang_tables")
|
||||
if not has_columns_meta:
|
||||
report.errors.append("缺少数据管理元数据表 _jiangchang_columns")
|
||||
if not has_tables_meta or not has_columns_meta:
|
||||
return report
|
||||
|
||||
fk_errors, _ = validate_no_sqlite_foreign_keys(cur)
|
||||
report.errors.extend(fk_errors)
|
||||
|
||||
for table_name in iter_user_tables(cur):
|
||||
cur.execute(
|
||||
"SELECT display_name FROM _jiangchang_tables WHERE table_name = ?",
|
||||
(table_name,),
|
||||
)
|
||||
row = cur.fetchone()
|
||||
if not row or not str(row[0] or "").strip():
|
||||
report.errors.append(f"业务表 {table_name!r} 缺少 _jiangchang_tables.display_name")
|
||||
elif not _has_cjk(str(row[0])):
|
||||
report.errors.append(f"业务表 {table_name!r} 的 display_name 应使用中文业务名称")
|
||||
|
||||
physical_columns = list_physical_column_names(cur, table_name)
|
||||
if check_column_order:
|
||||
report.warnings.extend(column_order_warnings(table_name, physical_columns))
|
||||
|
||||
for column_name in physical_columns:
|
||||
cur.execute(
|
||||
"""
|
||||
SELECT display_name, visible
|
||||
FROM _jiangchang_columns
|
||||
WHERE table_name = ? AND column_name = ?
|
||||
""",
|
||||
(table_name, column_name),
|
||||
)
|
||||
col_row = cur.fetchone()
|
||||
if not col_row:
|
||||
report.errors.append(
|
||||
f"字段 {table_name}.{column_name} 缺少 _jiangchang_columns 元数据"
|
||||
)
|
||||
continue
|
||||
display_name = str(col_row[0] or "").strip()
|
||||
visible = col_row[1] is None or int(col_row[1]) != 0
|
||||
if visible and not display_name:
|
||||
report.errors.append(f"字段 {table_name}.{column_name} 的 display_name 为空")
|
||||
elif visible and _looks_like_raw_physical_name(display_name, column_name):
|
||||
report.errors.append(
|
||||
f"字段 {table_name}.{column_name} 的 display_name 不应直接等于英文物理名：{display_name!r}"
|
||||
)
|
||||
elif visible and not _has_cjk(display_name):
|
||||
report.errors.append(
|
||||
f"字段 {table_name}.{column_name} 的 display_name 应使用中文：{display_name!r}"
|
||||
)
|
||||
|
||||
ts_errors, ts_warnings = validate_standard_timestamp_columns(
|
||||
cur,
|
||||
table_name,
|
||||
physical_columns=physical_columns,
|
||||
)
|
||||
report.errors.extend(ts_errors)
|
||||
report.warnings.extend(ts_warnings)
|
||||
|
||||
perm_errors, perm_warnings = validate_column_permissions(
|
||||
cur,
|
||||
table_name,
|
||||
physical_columns=physical_columns,
|
||||
)
|
||||
report.errors.extend(perm_errors)
|
||||
report.warnings.extend(perm_warnings)
|
||||
|
||||
_, filter_warnings = validate_filter_search_metadata(cur, table_name)
|
||||
report.warnings.extend(filter_warnings)
|
||||
|
||||
cur.execute("SELECT table_name, column_name FROM _jiangchang_columns")
|
||||
for table_name, column_name in cur.fetchall():
|
||||
if table_name in METADATA_TABLES:
|
||||
continue
|
||||
cur.execute(
|
||||
"SELECT 1 FROM sqlite_master WHERE type='table' AND name = ?",
|
||||
(table_name,),
|
||||
)
|
||||
if not cur.fetchone():
|
||||
report.errors.append(f"元数据引用了不存在的表：{table_name!r}")
|
||||
continue
|
||||
physical = list_physical_column_names(cur, str(table_name))
|
||||
if str(column_name) not in physical:
|
||||
report.errors.append(f"元数据引用了不存在的字段：{table_name}.{column_name}")
|
||||
|
||||
cur.execute("SELECT table_name FROM _jiangchang_tables")
|
||||
for (table_name,) in cur.fetchall():
|
||||
if table_name in METADATA_TABLES:
|
||||
continue
|
||||
cur.execute(
|
||||
"SELECT 1 FROM sqlite_master WHERE type='table' AND name = ?",
|
||||
(table_name,),
|
||||
)
|
||||
if not cur.fetchone():
|
||||
report.errors.append(f"元数据引用了不存在的表：{table_name!r}")
|
||||
|
||||
return report
|
||||
|
||||
|
||||
def validate_template_database(conn: sqlite3.Connection) -> ValidationReport:
|
||||
"""模板自检入口：校验展示元数据完整性，并扫描业务表 DDL 是否含 SQLite 外键。"""
|
||||
return validate_display_metadata(conn)
|
||||
50
scripts/db/timestamp_columns.py
Normal file
50
scripts/db/timestamp_columns.py
Normal file
@@ -0,0 +1,50 @@
|
||||
"""标准时间字段：Unix 秒级时间戳、默认值与 updated_at 自动维护。
|
||||
|
||||
业务表若包含 created_at / updated_at，在 CREATE TABLE 后调用
|
||||
``init_updated_at_trigger(cursor, table_name)``。模板默认不建业务表。
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
STANDARD_TIMESTAMP_COLUMNS = frozenset({"created_at", "updated_at"})
|
||||
DATETIME_UNIX_SECONDS = "datetime_unix_seconds"
|
||||
|
||||
|
||||
def updated_at_trigger_name(table_name: str) -> str:
|
||||
return f"{table_name}_set_updated_at"
|
||||
|
||||
|
||||
def _quote_identifier(name: str) -> str:
|
||||
return '"' + name.replace('"', '""') + '"'
|
||||
|
||||
|
||||
def init_updated_at_trigger(cursor, table_name: str) -> None:
|
||||
"""幂等创建 {table}_set_updated_at：业务字段 UPDATE 后刷新 updated_at。"""
|
||||
trigger = updated_at_trigger_name(table_name)
|
||||
quoted = _quote_identifier(table_name)
|
||||
quoted_trigger = _quote_identifier(trigger)
|
||||
cursor.execute(
|
||||
f"""
|
||||
CREATE TRIGGER IF NOT EXISTS {quoted_trigger}
|
||||
AFTER UPDATE ON {quoted}
|
||||
FOR EACH ROW
|
||||
BEGIN
|
||||
UPDATE {quoted}
|
||||
SET updated_at = unixepoch()
|
||||
WHERE id = NEW.id AND updated_at = OLD.updated_at;
|
||||
END
|
||||
"""
|
||||
)
|
||||
|
||||
|
||||
def has_updated_at_trigger(cursor, table_name: str) -> bool:
|
||||
trigger_name = updated_at_trigger_name(table_name)
|
||||
cursor.execute(
|
||||
"""
|
||||
SELECT 1 FROM sqlite_master
|
||||
WHERE type = 'trigger' AND name = ? AND tbl_name = ?
|
||||
LIMIT 1
|
||||
""",
|
||||
(trigger_name, table_name),
|
||||
)
|
||||
return cursor.fetchone() is not None
|
||||
38
scripts/main.py
Normal file
38
scripts/main.py
Normal file
@@ -0,0 +1,38 @@
|
||||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
skill-template CLI 入口。
|
||||
|
||||
复制为新技能后，请修改注释与常量，但保留当前分层结构：
|
||||
cli（argv）→ service（业务编排）→ db（持久化）→ util（通用工具）。
|
||||
|
||||
jiangchang_skill_core 来自宿主共享 Python runtime 安装的 jiangchang-platform-kit，
|
||||
不在技能仓库内 vendored。
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import sys
|
||||
|
||||
if sys.platform == "win32":
|
||||
import io
|
||||
|
||||
sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace")
|
||||
sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8", errors="replace")
|
||||
|
||||
_scripts_dir = os.path.dirname(os.path.abspath(__file__))
|
||||
if _scripts_dir not in sys.path:
|
||||
sys.path.insert(0, _scripts_dir)
|
||||
|
||||
from jiangchang_skill_core.runtime_env import apply_cli_local_defaults
|
||||
|
||||
apply_cli_local_defaults()
|
||||
|
||||
from util.config_bootstrap import bootstrap_skill_config
|
||||
|
||||
bootstrap_skill_config()
|
||||
|
||||
from cli.app import main
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
86
scripts/service/docx_service.py
Normal file
86
scripts/service/docx_service.py
Normal file
@@ -0,0 +1,86 @@
|
||||
"""Word 初稿渲染（python-docx）。
|
||||
|
||||
初稿结构：封面信息 → 目录骨架 → 六章（3/4/5 章自动成文，1/2/6 章素材要点 + [待补充] 占位）。
|
||||
写入技能 output/ 目录（用户可取）。python-docx 为技能特有依赖（requirements.txt 声明）。
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
|
||||
from util.logging_config import get_skill_logger
|
||||
from util.runtime_paths import get_output_dir
|
||||
|
||||
|
||||
def _log():
|
||||
try:
|
||||
return get_skill_logger()
|
||||
except RuntimeError:
|
||||
return None
|
||||
|
||||
|
||||
def _check_docx_available() -> None:
|
||||
try:
|
||||
import docx # noqa: F401
|
||||
except ImportError as exc:
|
||||
raise RuntimeError(
|
||||
"python-docx 未安装（技能依赖安装异常）；请重新安装技能，或先用 HTML 预览查看初稿内容。"
|
||||
) from exc
|
||||
|
||||
|
||||
def write_docx(project: dict[str, Any], sections: dict[str, list[str]], batch_no: str) -> str:
|
||||
"""生成《结题报告（初稿）》docx，返回文件路径。"""
|
||||
_check_docx_available()
|
||||
import docx
|
||||
from docx.shared import Pt
|
||||
|
||||
log = _log()
|
||||
log.info("docx_render_start project_no=%s stage=docx", project.get("project_no"))
|
||||
|
||||
document = docx.Document()
|
||||
|
||||
title = document.add_heading("结题报告（初稿）", level=0)
|
||||
title.alignment = 1
|
||||
|
||||
info_table = document.add_table(rows=0, cols=2)
|
||||
info_table.style = "Table Grid"
|
||||
for label, value in (
|
||||
("项目名称", project.get("project_name")),
|
||||
("项目编号", project.get("project_no")),
|
||||
("项目负责人", project.get("pi_name")),
|
||||
("所属学院", project.get("department")),
|
||||
("项目类型", project.get("program")),
|
||||
("执行周期", f"{project.get('start_date') or '—'} ~ {project.get('end_date') or '—'}"),
|
||||
("生成批次", batch_no),
|
||||
):
|
||||
row = info_table.add_row().cells
|
||||
row[0].text = str(label)
|
||||
row[1].text = str(value if value not in (None, "") else "—")
|
||||
|
||||
document.add_heading("目录（骨架，终稿请按本单位模板调整）", level=1)
|
||||
for section_title in sections:
|
||||
document.add_paragraph(section_title, style="List Number")
|
||||
|
||||
for section_title, paragraphs in sections.items():
|
||||
document.add_heading(section_title, level=1)
|
||||
for paragraph in paragraphs:
|
||||
text = str(paragraph)
|
||||
p = document.add_paragraph()
|
||||
run = p.add_run(text)
|
||||
if text.startswith("[待补充"):
|
||||
run.font.color.rgb = None # 占位文本以提示语区分，不依赖颜色
|
||||
run.italic = True
|
||||
|
||||
notice = document.add_paragraph()
|
||||
notice_run = notice.add_run(
|
||||
"说明：本初稿由结题报告初稿助手按台账数据自动生成；数字章节（完成情况/决算/成果清单）请逐项核对，"
|
||||
"叙事章节仅提供素材要点，须由项目负责人本人撰写终稿；严禁引入台账之外的成果或结论。"
|
||||
)
|
||||
notice_run.font.size = Pt(9)
|
||||
|
||||
project_no = str(project.get("project_no") or "未编号")
|
||||
filename = f"结题报告初稿-{project_no}.docx"
|
||||
path = get_output_dir() + "/" + filename
|
||||
document.save(path)
|
||||
log.info("docx_render_done project_no=%s path=%s stage=docx", project_no, path)
|
||||
return path
|
||||
354
scripts/service/draft_service.py
Normal file
354
scripts/service/draft_service.py
Normal file
@@ -0,0 +1,354 @@
|
||||
"""结题报告初稿生成内核（唯一业务内核）。
|
||||
|
||||
五步组装（对齐《核心建设内容：各部门"Skill"深度需求规格书》科研处 Skill 002）：
|
||||
C1 指标对比：按成果类型汇总实际数量 vs 预期指标 → 超额完成/持平/未达标/数据待补
|
||||
C2 完成情况章节：逐指标成文 + 成果明细（来源标注）
|
||||
C3 决算转换：按科目汇总金额与占比，生成规范描述句（金额不改写）
|
||||
C4 素材要点：代表性成果与年度报告摘句逐条提取（标注来源）
|
||||
C5 骨架组装：通用结题结构，叙事章节只放素材要点 + [待补充] 指引
|
||||
W1 数据完整性：缺数据生成占位，不阻塞整稿
|
||||
|
||||
红线：初稿中每个数字都来自台账；严禁编造数据与虚构论文结论。
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import uuid
|
||||
from datetime import date
|
||||
from typing import Any, Optional
|
||||
|
||||
from db.connection import get_conn, init_db
|
||||
from util.logging_config import get_skill_logger
|
||||
from util.timeutil import now_unix
|
||||
|
||||
_PLACEHOLDER = "[待补充：请结合素材要点与原始报告撰写，注意引用本人成果]"
|
||||
|
||||
_EXPENSE_SENTENCE_TEMPLATES = {
|
||||
"设备费": "购置/使用科研设备",
|
||||
"材料费": "采购实验材料",
|
||||
"测试化验加工费": "开展测试化验与加工",
|
||||
"燃料动力费": "支付燃料动力费用",
|
||||
"差旅费": "赴外开展调研与学术交流",
|
||||
"会议费": "组织/参加学术会议",
|
||||
"国际合作与交流费": "开展国际合作与交流",
|
||||
"出版/文献/信息传播/知识产权事务费": "支付出版与知识产权事务费用",
|
||||
"劳务费": "支付参与项目的研究生与临时聘用人员劳务",
|
||||
"专家咨询费": "支付专家咨询费用",
|
||||
"其他": "其他与项目研究直接相关的支出",
|
||||
}
|
||||
|
||||
|
||||
def _log():
|
||||
try:
|
||||
return get_skill_logger()
|
||||
except RuntimeError:
|
||||
return None
|
||||
|
||||
|
||||
def _wan(value: Optional[float]) -> str:
|
||||
if value is None:
|
||||
return "—"
|
||||
return f"{value / 10000:.2f} 万元"
|
||||
|
||||
|
||||
def _camel(name: str) -> str:
|
||||
parts = str(name).split("_")
|
||||
if len(parts) <= 1:
|
||||
return str(name)
|
||||
head, *rest = parts
|
||||
return head + "".join(p[:1].upper() + p[1:] for p in rest if p)
|
||||
|
||||
|
||||
def _snake(name: str) -> str:
|
||||
return "".join("_" + ch.lower() if ch.isupper() else ch for ch in str(name)).lstrip("_")
|
||||
|
||||
|
||||
def _norm_project(raw: dict[str, Any]) -> dict[str, Any]:
|
||||
aliases = {
|
||||
"projectNo": ("project_no", "项目编号"),
|
||||
"projectName": ("project_name", "项目名称"),
|
||||
"piName": ("pi_name", "负责人"),
|
||||
"department": ("department", "学院", "所属学院"),
|
||||
"program": ("program", "项目类型", "资助渠道"),
|
||||
"startDate": ("start_date", "执行期开始", "开始日期"),
|
||||
"endDate": ("end_date", "执行期结束", "结束日期"),
|
||||
"expected": ("expected_json", "预期成果指标", "预期指标"),
|
||||
"annualReportExcerpt": ("annual_report_excerpt", "年度报告摘句", "年度报告"),
|
||||
"status": ("status", "状态"),
|
||||
}
|
||||
out: dict[str, Any] = {}
|
||||
for key, value in raw.items():
|
||||
out.setdefault(str(key), value)
|
||||
for canonical, names in aliases.items():
|
||||
if str(key) in names or _camel(str(key)) == canonical:
|
||||
out.setdefault(canonical, value)
|
||||
return out
|
||||
|
||||
|
||||
def _norm_achievement(raw: dict[str, Any]) -> dict[str, Any]:
|
||||
aliases = {
|
||||
"projectNo": ("project_no", "项目编号"),
|
||||
"achievementType": ("achievement_type", "成果类型", "类型"),
|
||||
"title": ("title", "成果名称", "标题"),
|
||||
"venueOrNo": ("venue_or_no", "期刊/专利号", "期刊", "专利号"),
|
||||
"achDate": ("ach_date", "日期", "发表日期"),
|
||||
"isRepresentative": ("is_representative", "代表性成果"),
|
||||
"note": ("note", "备注"),
|
||||
}
|
||||
out: dict[str, Any] = {}
|
||||
for key, value in raw.items():
|
||||
out.setdefault(str(key), value)
|
||||
for canonical, names in aliases.items():
|
||||
if str(key) in names or _camel(str(key)) == canonical:
|
||||
out.setdefault(canonical, value)
|
||||
return out
|
||||
|
||||
|
||||
def _norm_expense(raw: dict[str, Any]) -> dict[str, Any]:
|
||||
aliases = {
|
||||
"projectNo": ("project_no", "项目编号"),
|
||||
"category": ("category", "科目"),
|
||||
"amount": ("amount", "金额"),
|
||||
"occurredDate": ("occurred_date", "发生日期"),
|
||||
"description": ("description", "原始摘要", "描述"),
|
||||
}
|
||||
out: dict[str, Any] = {}
|
||||
for key, value in raw.items():
|
||||
out.setdefault(str(key), value)
|
||||
for canonical, names in aliases.items():
|
||||
if str(key) in names or _camel(str(key)) == canonical:
|
||||
out.setdefault(canonical, value)
|
||||
return out
|
||||
|
||||
|
||||
def _c1_compare(expected: list[dict[str, Any]], achievements: list[dict[str, Any]]) -> list[dict[str, Any]]:
|
||||
"""C1：按类型对比预期指标与实际成果。"""
|
||||
counts: dict[str, int] = {}
|
||||
for ach in achievements:
|
||||
ach_type = str(ach.get("achievement_type") or "").strip()
|
||||
counts[ach_type] = counts.get(ach_type, 0) + 1
|
||||
rows = []
|
||||
for item in expected:
|
||||
item_type = str(item.get("type") or "").strip()
|
||||
target = item.get("target")
|
||||
try:
|
||||
target_v = int(float(target))
|
||||
except (TypeError, ValueError):
|
||||
target_v = None
|
||||
unit = str(item.get("unit") or "项")
|
||||
actual = counts.get(item_type)
|
||||
if target_v is None:
|
||||
verdict, detail = "数据待补", f"预期指标未配置数值（类型：{item_type}）"
|
||||
elif actual is None:
|
||||
verdict, detail = "未达标", f"预期 {target_v} {unit}，台账中未录入该类成果"
|
||||
else:
|
||||
if actual > target_v:
|
||||
verdict = "超额完成"
|
||||
elif actual == target_v:
|
||||
verdict = "持平"
|
||||
else:
|
||||
verdict = "未达标"
|
||||
detail = f"预期 {target_v} {unit}，实际 {actual} {unit}，{verdict}"
|
||||
rows.append({"type": item_type, "target": target_v, "unit": unit, "actual": actual, "verdict": verdict, "detail": detail})
|
||||
return rows
|
||||
|
||||
|
||||
def _c3_expense_sentences(expenses: list[dict[str, Any]], total_approved: Optional[float]) -> tuple[list[dict[str, Any]], str]:
|
||||
"""C3：按科目汇总并生成规范描述句。返回 (rows, 汇总段落)。"""
|
||||
by_category: dict[str, float] = {}
|
||||
for item in expenses:
|
||||
try:
|
||||
amount = float(item.get("amount") or 0)
|
||||
except (TypeError, ValueError):
|
||||
amount = 0.0
|
||||
category = str(item.get("category") or "其他").strip() or "其他"
|
||||
by_category[category] = by_category.get(category, 0.0) + amount
|
||||
total = round(sum(by_category.values()), 2)
|
||||
rows = []
|
||||
sentences = []
|
||||
for category, amount in sorted(by_category.items(), key=lambda kv: -kv[1]):
|
||||
ratio = round(amount / total, 4) if total > 0 else 0.0
|
||||
action = _EXPENSE_SENTENCE_TEMPLATES.get(category, f"开展{category}相关支出")
|
||||
sentence = f"{action}，支出 {_wan(amount)}，占比 {ratio * 100:.1f}%"
|
||||
rows.append({"category": category, "amount": round(amount, 2), "ratio": ratio, "sentence": sentence})
|
||||
sentences.append(sentence)
|
||||
if not rows:
|
||||
return [], "经费决算明细尚未录入，请在补录后重新生成初稿（W1）。"
|
||||
tail = f"。项目决算合计支出 {_wan(total)}。"
|
||||
if total_approved is not None:
|
||||
tail += "支出总额控制在立项经费范围内。" if total <= total_approved else "支出总额超出立项经费，请补充说明。"
|
||||
return rows, "本项目经费支出按科目如下：" + "；".join(sentences) + "。" + tail
|
||||
|
||||
|
||||
def _c4_narrative_points(achievements: list[dict[str, Any]], excerpt: str) -> list[dict[str, str]]:
|
||||
"""C4：从代表性成果与年度报告摘句提取叙事素材要点。"""
|
||||
points = []
|
||||
for ach in achievements:
|
||||
if ach.get("is_representative"):
|
||||
title = str(ach.get("title") or "").strip()
|
||||
venue = str(ach.get("venue_or_no") or "").strip()
|
||||
points.append({"source": "成果清单", "point": f"代表性成果：{title}" + (f"（{venue}）" if venue else "")})
|
||||
for sentence in str(excerpt or "").replace("；", "。").split("。"):
|
||||
sentence = sentence.strip()
|
||||
if sentence:
|
||||
points.append({"source": "年度报告", "point": sentence})
|
||||
return points
|
||||
|
||||
|
||||
def build_draft_sections(
|
||||
project: dict[str, Any],
|
||||
achievements: list[dict[str, Any]],
|
||||
expenses: list[dict[str, Any]],
|
||||
) -> dict[str, Any]:
|
||||
"""组装初稿各章节数据（纯计算，不落库不出文件）。"""
|
||||
import json as _json
|
||||
|
||||
project = _norm_project(project)
|
||||
raw_expected = project.get("expected_json")
|
||||
if raw_expected in (None, ""):
|
||||
raw_expected = project.get("expected") or project.get("expectedJson") or []
|
||||
if isinstance(raw_expected, str):
|
||||
try:
|
||||
expected = _json.loads(raw_expected)
|
||||
except (TypeError, ValueError):
|
||||
expected = []
|
||||
elif isinstance(raw_expected, list):
|
||||
expected = raw_expected
|
||||
else:
|
||||
expected = []
|
||||
if isinstance(expected, dict):
|
||||
expected = expected.get("indicators") or []
|
||||
|
||||
achievements = [{_snake(k): v for k, v in _norm_achievement(a).items()} for a in achievements]
|
||||
expenses = [{_snake(k): v for k, v in _norm_expense(e).items()} for e in expenses]
|
||||
|
||||
completion = _c1_compare(expected, achievements)
|
||||
expense_rows, expense_paragraph = _c3_expense_sentences(expenses, None)
|
||||
excerpt = project.get("annual_report_excerpt") or project.get("annualReportExcerpt") or ""
|
||||
narrative_points = _c4_narrative_points(achievements, str(excerpt))
|
||||
|
||||
achievement_lines = []
|
||||
for ach in achievements:
|
||||
title = str(ach.get("title") or "").strip()
|
||||
venue = str(ach.get("venue_or_no") or "").strip()
|
||||
ach_date = str(ach.get("ach_date") or "").strip()
|
||||
line = f"{ach.get('achievement_type')}：{title}" + (f"（{venue}，{ach_date}）" if venue or ach_date else "")
|
||||
achievement_lines.append(line + "。来源：成果清单")
|
||||
|
||||
sections = {
|
||||
"1. 研究背景与目标": [_PLACEHOLDER],
|
||||
"2. 研究内容与进展": (
|
||||
[f"· {p['point']}（来源：{p['source']}）" for p in narrative_points] or [f"· {_PLACEHOLDER}"]
|
||||
) + [_PLACEHOLDER],
|
||||
"3. 预期成果完成情况": [f"{row['type']}：{row['detail']}。来源：预期指标与成果清单" for row in completion]
|
||||
or ["预期成果指标未配置，请在项目台账补录后重新生成（W1）。"],
|
||||
"4. 经费决算说明": [expense_paragraph, "明细："] + [f"· {row['sentence']}" for row in expense_rows],
|
||||
"5. 成果清单": achievement_lines or ["成果清单尚未录入，请在补录后重新生成初稿（W1）。"],
|
||||
"6. 存在问题与展望": [_PLACEHOLDER],
|
||||
}
|
||||
return {
|
||||
"completion": completion,
|
||||
"expense_rows": expense_rows,
|
||||
"expense_paragraph": expense_paragraph,
|
||||
"narrative_points": narrative_points,
|
||||
"achievement_lines": achievement_lines,
|
||||
"sections": sections,
|
||||
}
|
||||
|
||||
|
||||
def run_draft(project_raw: dict[str, Any], achievements: list[dict[str, Any]], expenses: list[dict[str, Any]], *, batch_no: str = "") -> dict[str, Any]:
|
||||
"""初稿内核：三步生成 → 写 docx + HTML 预览 → 落库。"""
|
||||
from service.docx_service import write_docx
|
||||
from service.report_service import write_preview_for_kernel
|
||||
|
||||
log = _log()
|
||||
init_db()
|
||||
project = _norm_project(project_raw)
|
||||
project_no = str(project.get("project_no") or "").strip()
|
||||
if not project_no:
|
||||
raise ValueError("项目编号（project_no）不能为空")
|
||||
batch_no = batch_no or now_unix().to_bytes(5, "big").hex() + uuid.uuid4().hex[:6]
|
||||
|
||||
if log:
|
||||
log.info("draft_kernel_start batch_no=%s project_no=%s stage=kernel", batch_no, project_no)
|
||||
|
||||
sections_data = build_draft_sections(project, achievements, expenses)
|
||||
sections = sections_data["sections"]
|
||||
|
||||
draft_file = write_docx(project, sections, batch_no)
|
||||
|
||||
draft = {
|
||||
"project_no": project_no,
|
||||
"project_name": str(project.get("project_name") or ""),
|
||||
"batch_no": batch_no,
|
||||
"sections": sections,
|
||||
"completion": sections_data["completion"],
|
||||
"narrative_points": sections_data["narrative_points"],
|
||||
}
|
||||
preview_file = write_preview_for_kernel(draft=draft)
|
||||
|
||||
conn = get_conn()
|
||||
try:
|
||||
cur = conn.cursor()
|
||||
cur.execute(
|
||||
"""
|
||||
INSERT INTO report_drafts
|
||||
(batch_no, project_no, project_name, completion_json, narrative_points_json, draft_file, preview_file)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?)
|
||||
""",
|
||||
(
|
||||
batch_no,
|
||||
project_no,
|
||||
str(project.get("project_name") or ""),
|
||||
json.dumps(sections_data["completion"], ensure_ascii=False),
|
||||
json.dumps(sections_data["narrative_points"], ensure_ascii=False),
|
||||
draft_file,
|
||||
preview_file,
|
||||
),
|
||||
)
|
||||
draft_id = int(cur.lastrowid)
|
||||
cur.execute(
|
||||
"UPDATE closing_projects SET status = '初稿已生成', updated_at = ? WHERE project_no = ?",
|
||||
(now_unix(), project_no),
|
||||
)
|
||||
conn.commit()
|
||||
finally:
|
||||
conn.close()
|
||||
|
||||
payload = {
|
||||
"ok": True,
|
||||
"batch_no": batch_no,
|
||||
"draft_id": draft_id,
|
||||
"project_no": project_no,
|
||||
"draft_file": draft_file,
|
||||
"preview_file": preview_file,
|
||||
"completion": sections_data["completion"],
|
||||
"narrative_points_count": len(sections_data["narrative_points"]),
|
||||
"disclaimer": "初稿由台账数据与模板生成；数据章节请核对，叙事章节须本人终审，严禁引入台账之外的成果。",
|
||||
}
|
||||
if log:
|
||||
log.info("draft_kernel_done batch_no=%s project_no=%s draft_id=%s stage=kernel", batch_no, project_no, draft_id)
|
||||
return payload
|
||||
|
||||
|
||||
def query_pending_projects(project_no: str = "") -> list[dict[str, Any]]:
|
||||
"""读取待结题项目（可按项目编号筛选），附成果与决算数量。"""
|
||||
conn = get_conn()
|
||||
try:
|
||||
cur = conn.cursor()
|
||||
if project_no:
|
||||
cur.execute("SELECT * FROM closing_projects WHERE project_no = ?", (project_no,))
|
||||
else:
|
||||
cur.execute("SELECT * FROM closing_projects WHERE status = '待结题' ORDER BY id")
|
||||
columns = [d[0] for d in cur.description]
|
||||
projects = [dict(zip(columns, row)) for row in cur.fetchall()]
|
||||
for project in projects:
|
||||
pno = project.get("project_no")
|
||||
cur.execute("SELECT COUNT(*) FROM achievements WHERE project_no = ?", (pno,))
|
||||
project["achievement_count"] = int(cur.fetchone()[0])
|
||||
cur.execute("SELECT COUNT(*) FROM expense_items WHERE project_no = ?", (pno,))
|
||||
project["expense_count"] = int(cur.fetchone()[0])
|
||||
finally:
|
||||
conn.close()
|
||||
return projects
|
||||
46
scripts/service/entitlement_service.py
Normal file
46
scripts/service/entitlement_service.py
Normal file
@@ -0,0 +1,46 @@
|
||||
"""在线鉴权（可选模板）。"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Tuple
|
||||
|
||||
import requests
|
||||
from jiangchang_skill_core import config
|
||||
|
||||
|
||||
def check_entitlement(skill_slug: str) -> Tuple[bool, str]:
|
||||
auth_base = (config.get("JIANGCHANG_AUTH_BASE_URL") or "").strip().rstrip("/")
|
||||
if not auth_base:
|
||||
return True, ""
|
||||
user_id = (config.get("JIANGCHANG_USER_ID") or "").strip()
|
||||
if not user_id:
|
||||
return False, "鉴权失败：缺少用户身份（JIANGCHANG_USER_ID）"
|
||||
|
||||
auth_api_key = (config.get("JIANGCHANG_AUTH_API_KEY") or "").strip()
|
||||
timeout = int((config.get("JIANGCHANG_AUTH_TIMEOUT_SECONDS") or "5").strip())
|
||||
headers = {"Content-Type": "application/json"}
|
||||
if auth_api_key:
|
||||
headers["Authorization"] = f"Bearer {auth_api_key}"
|
||||
payload = {
|
||||
"user_id": user_id,
|
||||
"skill_slug": skill_slug,
|
||||
"trace_id": (config.get("JIANGCHANG_TRACE_ID") or "").strip(),
|
||||
"context": {"entry": "main.py"},
|
||||
}
|
||||
try:
|
||||
res = requests.post(f"{auth_base}/api/entitlements/check", json=payload, headers=headers, timeout=timeout)
|
||||
except requests.RequestException as exc:
|
||||
return False, f"鉴权请求失败：{exc}"
|
||||
if res.status_code != 200:
|
||||
return False, f"鉴权服务异常：HTTP {res.status_code}"
|
||||
try:
|
||||
body = res.json()
|
||||
except ValueError:
|
||||
return False, "鉴权服务异常：返回非 JSON"
|
||||
code = body.get("code")
|
||||
data = body.get("data") or {}
|
||||
if code != 200:
|
||||
return False, str(body.get("msg") or "鉴权失败")
|
||||
if not data.get("allow", False):
|
||||
return False, str(data.get("reason") or "未购买或已过期")
|
||||
return True, ""
|
||||
78
scripts/service/html_page_service.py
Normal file
78
scripts/service/html_page_service.py
Normal file
@@ -0,0 +1,78 @@
|
||||
"""技能 HTML 报告页：写入 `{skill_data}/html/*.html`（宿主扫描预览）。
|
||||
|
||||
契约要点（权威说明见 `references/ACTIONS.md`「HTML 页面报告」）：
|
||||
|
||||
- 目录：仅一层 `html/*.html`（非递归）
|
||||
- 重新生成 Action id 必须为 `render-html`（宿主硬编码）
|
||||
- 页面布局底线见 `references/ACTIONS.md`「宿主预览布局」；模板壳 `assets/html/example-report.html`
|
||||
- 成功后建议 `steps: refreshCatalog` 以重扫侧栏
|
||||
- 本模块只提供路径/模板/原子写；业务 KPI/表格由各技能自行填充
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import re
|
||||
from typing import Mapping
|
||||
|
||||
from util.logging_config import get_skill_logger
|
||||
from util.runtime_paths import get_html_dir, get_skill_root
|
||||
|
||||
# Host Data Management looks up this exact Skill Action id for「重新生成」.
|
||||
HOST_HTML_RENDER_ACTION_ID = "render-html"
|
||||
|
||||
_UNSAFE_NAME = re.compile(r"[\\/]|^\.\.|\.\.$")
|
||||
|
||||
|
||||
def _log():
|
||||
try:
|
||||
return get_skill_logger()
|
||||
except RuntimeError:
|
||||
return None
|
||||
|
||||
|
||||
def assert_html_filename(filename: str) -> str:
|
||||
name = (filename or "").strip()
|
||||
if not name.lower().endswith(".html"):
|
||||
raise ValueError(f"html filename must end with .html: {filename!r}")
|
||||
if _UNSAFE_NAME.search(name) or "/" in name or "\\" in name:
|
||||
raise ValueError(f"html filename must be a basename only: {filename!r}")
|
||||
if len(name) > 200:
|
||||
raise ValueError(f"html filename too long: {filename!r}")
|
||||
return name
|
||||
|
||||
|
||||
def html_page_path(filename: str, *, create_dir: bool = True) -> str:
|
||||
return os.path.join(get_html_dir(create=create_dir), assert_html_filename(filename))
|
||||
|
||||
|
||||
def load_html_template(relative_under_skill_root: str) -> str:
|
||||
"""Load UTF-8 template from skill root (e.g. ``assets/html/example-report.html``)."""
|
||||
rel = (relative_under_skill_root or "").strip().replace("\\", "/")
|
||||
if not rel or rel.startswith("/") or ".." in rel.split("/"):
|
||||
raise ValueError(f"invalid template path: {relative_under_skill_root!r}")
|
||||
path = os.path.join(get_skill_root(), *rel.split("/"))
|
||||
with open(path, encoding="utf-8") as f:
|
||||
return f.read()
|
||||
|
||||
|
||||
def render_html_placeholders(template: str, mapping: Mapping[str, str]) -> str:
|
||||
"""Replace ``{{KEY}}`` tokens. Unknown keys are left as-is."""
|
||||
page = template
|
||||
for key, value in mapping.items():
|
||||
page = page.replace("{{" + str(key) + "}}", str(value))
|
||||
return page
|
||||
|
||||
|
||||
def write_html_page(filename: str, html: str) -> str:
|
||||
"""Atomically write UTF-8 HTML under ``html/``. Returns absolute path."""
|
||||
dest = html_page_path(filename, create_dir=True)
|
||||
tmp = dest + ".tmp"
|
||||
text = html if isinstance(html, str) else str(html)
|
||||
with open(tmp, "w", encoding="utf-8", newline="\n") as f:
|
||||
f.write(text)
|
||||
os.replace(tmp, dest)
|
||||
log = _log()
|
||||
if log:
|
||||
log.info("html_page_written path=%s bytes=%s", dest, len(text.encode("utf-8")))
|
||||
return dest
|
||||
313
scripts/service/ledger_service.py
Normal file
313
scripts/service/ledger_service.py
Normal file
@@ -0,0 +1,313 @@
|
||||
"""结题项目 / 成果清单 / 决算明细 / 初稿记录 的维护与查询。"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
from typing import Any, Optional
|
||||
|
||||
from db.connection import get_conn, init_db
|
||||
from service.draft_service import _norm_achievement, _norm_expense, _norm_project
|
||||
from util.logging_config import get_skill_logger
|
||||
from util.timeutil import now_unix
|
||||
|
||||
_PROJECT_TEXT_FIELDS = ("project_name", "pi_name", "department", "program", "start_date", "end_date", "annual_report_excerpt", "status")
|
||||
_KNOWN_STATUS = ("待结题", "初稿已生成", "已提交")
|
||||
_KNOWN_ACH_TYPES = ("论文", "专利", "人才培养", "其他")
|
||||
|
||||
|
||||
def _log():
|
||||
try:
|
||||
return get_skill_logger()
|
||||
except RuntimeError:
|
||||
return None
|
||||
|
||||
|
||||
def _snake(name: str) -> str:
|
||||
return "".join("_" + ch.lower() if ch.isupper() else ch for ch in str(name)).lstrip("_")
|
||||
|
||||
|
||||
def _to_float(value: Any) -> Optional[float]:
|
||||
if value is None or value == "":
|
||||
return None
|
||||
try:
|
||||
return float(value)
|
||||
except (TypeError, ValueError):
|
||||
return None
|
||||
|
||||
|
||||
def upsert_project(fields: dict[str, Any]) -> dict[str, Any]:
|
||||
fields = {_snake(k): v for k, v in _norm_project(fields).items()}
|
||||
project_no = str(fields.get("project_no") or "").strip()
|
||||
if not project_no:
|
||||
raise ValueError("项目编号（project_no）不能为空")
|
||||
values: dict[str, Any] = {"project_no": project_no}
|
||||
for key in _PROJECT_TEXT_FIELDS:
|
||||
if fields.get(key) not in (None, ""):
|
||||
values[key] = str(fields[key]).strip()
|
||||
if values.get("status") and values["status"] not in _KNOWN_STATUS:
|
||||
raise ValueError(f"status 只接受 {'、'.join(_KNOWN_STATUS)}：{values['status']}")
|
||||
if fields.get("expected_json") not in (None, ""):
|
||||
raw = fields["expected_json"]
|
||||
try:
|
||||
expected = json.loads(raw) if isinstance(raw, str) else raw
|
||||
except (TypeError, ValueError) as exc:
|
||||
raise ValueError(f"预期指标 JSON 解析失败：{exc}") from exc
|
||||
if not isinstance(expected, list):
|
||||
raise ValueError("预期指标应为数组，如 [{\"type\":\"论文\",\"target\":3,\"unit\":\"篇\"}]")
|
||||
values["expected_json"] = json.dumps(expected, ensure_ascii=False)
|
||||
|
||||
init_db()
|
||||
conn = get_conn()
|
||||
try:
|
||||
cur = conn.cursor()
|
||||
cur.execute("SELECT id FROM closing_projects WHERE project_no = ?", (project_no,))
|
||||
row = cur.fetchone()
|
||||
if row:
|
||||
project_id = int(row[0])
|
||||
set_clause = ", ".join(f"{k} = ?" for k in values if k != "project_no")
|
||||
cur.execute(
|
||||
f"UPDATE closing_projects SET {set_clause}, updated_at = ? WHERE id = ?",
|
||||
[values[k] for k in values if k != "project_no"] + [now_unix(), project_id],
|
||||
)
|
||||
action = "updated"
|
||||
else:
|
||||
columns = ", ".join(values.keys())
|
||||
placeholders = ", ".join("?" for _ in values)
|
||||
cur.execute(
|
||||
f"INSERT INTO closing_projects ({columns}, created_at, updated_at) VALUES ({placeholders}, ?, ?)",
|
||||
list(values.values()) + [now_unix(), now_unix()],
|
||||
)
|
||||
project_id = int(cur.lastrowid)
|
||||
action = "created"
|
||||
conn.commit()
|
||||
finally:
|
||||
conn.close()
|
||||
log = _log()
|
||||
if log:
|
||||
log.info("closing_project_upserted project_no=%s action=%s stage=ledger", project_no, action)
|
||||
return {"ok": True, "project_no": project_no, "id": project_id, "action": action}
|
||||
|
||||
|
||||
def upsert_achievement(fields: dict[str, Any]) -> dict[str, Any]:
|
||||
achievement = {_snake(k): v for k, v in _norm_achievement(fields).items()}
|
||||
project_no = str(achievement.get("project_no") or "").strip()
|
||||
title = str(achievement.get("title") or "").strip()
|
||||
ach_type = str(achievement.get("achievement_type") or "").strip()
|
||||
if not project_no:
|
||||
raise ValueError("项目编号（project_no）不能为空")
|
||||
if not ach_type:
|
||||
raise ValueError("成果类型（achievement_type）不能为空")
|
||||
if ach_type not in _KNOWN_ACH_TYPES:
|
||||
raise ValueError(f"成果类型只接受 {'、'.join(_KNOWN_ACH_TYPES)}：{ach_type}")
|
||||
if not title:
|
||||
raise ValueError("成果名称（title）不能为空")
|
||||
|
||||
values = {
|
||||
"project_no": project_no,
|
||||
"achievement_type": ach_type,
|
||||
"title": title,
|
||||
"venue_or_no": str(achievement.get("venue_or_no") or "").strip(),
|
||||
"ach_date": str(achievement.get("ach_date") or "").strip(),
|
||||
"is_representative": 1 if str(achievement.get("is_representative") or "").strip() in ("1", "true", "True", "是") else 0,
|
||||
"note": str(achievement.get("note") or "").strip(),
|
||||
}
|
||||
init_db()
|
||||
conn = get_conn()
|
||||
try:
|
||||
cur = conn.cursor()
|
||||
cur.execute("SELECT id FROM closing_projects WHERE project_no = ?", (project_no,))
|
||||
if not cur.fetchone():
|
||||
raise ValueError(f"项目不存在，请先录入结题项目：{project_no}")
|
||||
cur.execute(
|
||||
"""
|
||||
INSERT INTO achievements
|
||||
(project_no, achievement_type, title, venue_or_no, ach_date, is_representative, note, created_at, updated_at)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
""",
|
||||
list(values.values()) + [now_unix(), now_unix()],
|
||||
)
|
||||
achievement_id = int(cur.lastrowid)
|
||||
conn.commit()
|
||||
finally:
|
||||
conn.close()
|
||||
log = _log()
|
||||
if log:
|
||||
log.info("achievement_added project_no=%s type=%s stage=ledger", project_no, ach_type)
|
||||
return {"ok": True, "id": achievement_id, "project_no": project_no, "title": title}
|
||||
|
||||
|
||||
def upsert_expense(fields: dict[str, Any]) -> dict[str, Any]:
|
||||
expense = {_snake(k): v for k, v in _norm_expense(fields).items()}
|
||||
project_no = str(expense.get("project_no") or "").strip()
|
||||
category = str(expense.get("category") or "").strip()
|
||||
amount = _to_float(expense.get("amount"))
|
||||
if not project_no:
|
||||
raise ValueError("项目编号（project_no）不能为空")
|
||||
if not category:
|
||||
raise ValueError("科目（category）不能为空")
|
||||
if amount is None or amount < 0:
|
||||
raise ValueError(f"金额必须是非负数字：{fields.get('amount')}")
|
||||
|
||||
values = {
|
||||
"project_no": project_no,
|
||||
"category": category,
|
||||
"amount": round(amount, 2),
|
||||
"occurred_date": str(expense.get("occurred_date") or "").strip(),
|
||||
"description": str(expense.get("description") or "").strip(),
|
||||
}
|
||||
init_db()
|
||||
conn = get_conn()
|
||||
try:
|
||||
cur = conn.cursor()
|
||||
cur.execute("SELECT id FROM closing_projects WHERE project_no = ?", (project_no,))
|
||||
if not cur.fetchone():
|
||||
raise ValueError(f"项目不存在，请先录入结题项目：{project_no}")
|
||||
cur.execute(
|
||||
"""
|
||||
INSERT INTO expense_items
|
||||
(project_no, category, amount, occurred_date, description, created_at, updated_at)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?)
|
||||
""",
|
||||
list(values.values()) + [now_unix(), now_unix()],
|
||||
)
|
||||
expense_id = int(cur.lastrowid)
|
||||
conn.commit()
|
||||
finally:
|
||||
conn.close()
|
||||
log = _log()
|
||||
if log:
|
||||
log.info("expense_added project_no=%s category=%s stage=ledger", project_no, category)
|
||||
return {"ok": True, "id": expense_id, "project_no": project_no, "category": category, "amount": values["amount"]}
|
||||
|
||||
|
||||
def _import_generic(rows: Any, upsert, label: str) -> dict[str, Any]:
|
||||
if not isinstance(rows, list) or not rows:
|
||||
raise ValueError(f"导入内容应为非空 JSON 数组（{label}）")
|
||||
if len(rows) > 500:
|
||||
raise ValueError(f"单次导入条数过多（{len(rows)}），上限 500 条")
|
||||
results = []
|
||||
for idx, raw in enumerate(rows):
|
||||
if not isinstance(raw, dict):
|
||||
raise ValueError(f"第 {idx + 1} 条不是 JSON 对象")
|
||||
results.append(upsert(raw))
|
||||
return {
|
||||
"ok": True,
|
||||
"count": len(results),
|
||||
"created": sum(1 for r in results if r["action"] == "created"),
|
||||
"updated": sum(1 for r in results if r["action"] == "updated"),
|
||||
"items": results,
|
||||
}
|
||||
|
||||
|
||||
def import_projects(rows: list[dict[str, Any]]) -> dict[str, Any]:
|
||||
return _import_generic(rows, lambda row: upsert_project({_snake(k): v for k, v in _norm_project(row).items()}), "结题项目")
|
||||
|
||||
|
||||
def import_achievements(rows: list[dict[str, Any]]) -> dict[str, Any]:
|
||||
return _import_generic(rows, lambda row: upsert_achievement({_snake(k): v for k, v in _norm_achievement(row).items()}), "成果清单")
|
||||
|
||||
|
||||
def import_expenses(rows: list[dict[str, Any]]) -> dict[str, Any]:
|
||||
return _import_generic(rows, lambda row: upsert_expense({_snake(k): v for k, v in _norm_expense(row).items()}), "决算明细")
|
||||
|
||||
|
||||
def list_projects(status: str = "") -> list[dict[str, Any]]:
|
||||
init_db()
|
||||
conn = get_conn()
|
||||
try:
|
||||
cur = conn.cursor()
|
||||
if status:
|
||||
cur.execute("SELECT * FROM closing_projects WHERE status = ? ORDER BY id", (status,))
|
||||
else:
|
||||
cur.execute("SELECT * FROM closing_projects ORDER BY id")
|
||||
columns = [d[0] for d in cur.description]
|
||||
rows = [dict(zip(columns, row)) for row in cur.fetchall()]
|
||||
finally:
|
||||
conn.close()
|
||||
return rows
|
||||
|
||||
|
||||
def list_achievements(project_no: str) -> list[dict[str, Any]]:
|
||||
conn = get_conn()
|
||||
try:
|
||||
cur = conn.cursor()
|
||||
cur.execute("SELECT * FROM achievements WHERE project_no = ? ORDER BY id", (project_no,))
|
||||
columns = [d[0] for d in cur.description]
|
||||
rows = [dict(zip(columns, row)) for row in cur.fetchall()]
|
||||
finally:
|
||||
conn.close()
|
||||
return rows
|
||||
|
||||
|
||||
def list_expenses(project_no: str) -> list[dict[str, Any]]:
|
||||
conn = get_conn()
|
||||
try:
|
||||
cur = conn.cursor()
|
||||
cur.execute("SELECT * FROM expense_items WHERE project_no = ? ORDER BY id", (project_no,))
|
||||
columns = [d[0] for d in cur.description]
|
||||
rows = [dict(zip(columns, row)) for row in cur.fetchall()]
|
||||
finally:
|
||||
conn.close()
|
||||
return rows
|
||||
|
||||
|
||||
def list_drafts(limit: int = 20) -> list[dict[str, Any]]:
|
||||
init_db()
|
||||
limit = max(1, min(int(limit), 200))
|
||||
conn = get_conn()
|
||||
try:
|
||||
cur = conn.cursor()
|
||||
cur.execute(
|
||||
"SELECT id, batch_no, project_no, project_name, draft_file, preview_file, created_at FROM report_drafts ORDER BY id DESC LIMIT ?",
|
||||
(limit,),
|
||||
)
|
||||
columns = [d[0] for d in cur.description]
|
||||
rows = [dict(zip(columns, row)) for row in cur.fetchall()]
|
||||
finally:
|
||||
conn.close()
|
||||
return rows
|
||||
|
||||
|
||||
def get_draft(draft_id: int) -> dict[str, Any]:
|
||||
init_db()
|
||||
conn = get_conn()
|
||||
try:
|
||||
cur = conn.cursor()
|
||||
cur.execute("SELECT * FROM report_drafts WHERE id = ?", (draft_id,))
|
||||
row = cur.fetchone()
|
||||
if not row:
|
||||
raise ValueError(f"初稿记录不存在：{draft_id}")
|
||||
columns = [d[0] for d in cur.description]
|
||||
draft = dict(zip(columns, row))
|
||||
finally:
|
||||
conn.close()
|
||||
for key in ("completion_json", "narrative_points_json"):
|
||||
try:
|
||||
draft[key[:-5]] = json.loads(draft.get(key) or "[]")
|
||||
except (TypeError, ValueError):
|
||||
draft[key[:-5]] = []
|
||||
return draft
|
||||
|
||||
|
||||
def stats() -> dict[str, Any]:
|
||||
init_db()
|
||||
conn = get_conn()
|
||||
try:
|
||||
cur = conn.cursor()
|
||||
cur.execute("SELECT status, COUNT(*) FROM closing_projects GROUP BY status")
|
||||
by_status = {str(r[0]): int(r[1]) for r in cur.fetchall()}
|
||||
cur.execute("SELECT COUNT(*) FROM achievements")
|
||||
achievement_total = int(cur.fetchone()[0])
|
||||
cur.execute("SELECT COUNT(*) FROM expense_items")
|
||||
expense_total = int(cur.fetchone()[0])
|
||||
cur.execute("SELECT COUNT(*) FROM report_drafts")
|
||||
draft_total = int(cur.fetchone()[0])
|
||||
finally:
|
||||
conn.close()
|
||||
return {
|
||||
"ok": True,
|
||||
"projects_by_status": by_status,
|
||||
"achievement_total": achievement_total,
|
||||
"expense_total": expense_total,
|
||||
"draft_total": draft_total,
|
||||
}
|
||||
104
scripts/service/report_service.py
Normal file
104
scripts/service/report_service.py
Normal file
@@ -0,0 +1,104 @@
|
||||
"""初稿 HTML 预览组装。
|
||||
|
||||
与 Word 初稿同构内容写入 `{skill_data}/html/draft-{id}.html`，宿主侧栏可预览；
|
||||
重建走固定 Action id `render-html`。
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
from typing import Any
|
||||
|
||||
from service.html_page_service import load_html_template, render_html_placeholders, write_html_page
|
||||
from util.logging_config import get_skill_logger
|
||||
|
||||
_TEMPLATE_REL = "assets/html/draft-preview.html"
|
||||
|
||||
|
||||
def _esc(value: Any) -> str:
|
||||
import html
|
||||
|
||||
return html.escape(str(value if value is not None else "—"), quote=True)
|
||||
|
||||
|
||||
def _sections_html(sections: dict[str, list[str]]) -> str:
|
||||
parts = []
|
||||
for title, paragraphs in (sections or {}).items():
|
||||
items = "".join(f"<p class='para{' placeholder' if p.startswith('[待补充') else ''}'>{_esc(p)}</p>" for p in paragraphs)
|
||||
parts.append(f"<div class='section'><h2>{_esc(title)}</h2>{items}</div>")
|
||||
return "".join(parts)
|
||||
|
||||
|
||||
def build_preview_html(draft: dict[str, Any]) -> str:
|
||||
body = f"""
|
||||
<div class="verdict-line">
|
||||
<span class="tag tier-info">初稿</span>
|
||||
<span class="muted">项目 {_esc(draft.get("project_no"))} · 批次 {_esc(draft.get("batch_no"))}</span>
|
||||
</div>
|
||||
<div class="section"><h2>生成说明</h2>
|
||||
<p class="para">数据章节（完成情况/决算/成果清单）由台账自动生成，请逐项核对；叙事章节仅提供素材要点，须由项目负责人本人终审。</p>
|
||||
</div>
|
||||
{_sections_html(draft.get("sections") or {})}
|
||||
<footer>本预览与 Word 初稿同构；严禁引入台账之外的成果或结论。以本单位结题报告模板为准。</footer>
|
||||
"""
|
||||
template = load_html_template(_TEMPLATE_REL)
|
||||
return render_html_placeholders(
|
||||
template,
|
||||
{
|
||||
"TITLE": f"结题报告初稿预览 · {draft.get('project_name') or draft.get('project_no') or ''}",
|
||||
"GENERATED_AT": "",
|
||||
"BODY": body,
|
||||
},
|
||||
)
|
||||
|
||||
|
||||
def write_preview_for_kernel(*, draft: dict[str, Any]) -> str:
|
||||
html_text = build_preview_html(draft)
|
||||
log = get_skill_logger()
|
||||
path = write_html_page("draft-preview.html", html_text)
|
||||
log.info("draft_preview_written project_no=%s path=%s stage=report", draft.get("project_no"), path)
|
||||
return path
|
||||
|
||||
|
||||
def build_preview_for_draft_id(draft_id: int) -> str:
|
||||
"""按初稿记录 id 重建 HTML 预览（重建入口用）。"""
|
||||
from db.connection import get_conn
|
||||
|
||||
log = get_skill_logger()
|
||||
log.info("preview_render_start draft_id=%s stage=render", draft_id)
|
||||
conn = get_conn()
|
||||
try:
|
||||
cur = conn.cursor()
|
||||
cur.execute("SELECT * FROM report_drafts WHERE id = ?", (draft_id,))
|
||||
row = cur.fetchone()
|
||||
if not row:
|
||||
raise ValueError(f"初稿记录不存在：{draft_id}")
|
||||
columns = [d[0] for d in cur.description]
|
||||
record = dict(zip(columns, row))
|
||||
finally:
|
||||
conn.close()
|
||||
|
||||
try:
|
||||
completion = json.loads(record.get("completion_json") or "[]")
|
||||
except (TypeError, ValueError):
|
||||
completion = []
|
||||
try:
|
||||
narrative_points = json.loads(record.get("narrative_points_json") or "[]")
|
||||
except (TypeError, ValueError):
|
||||
narrative_points = []
|
||||
|
||||
sections: dict[str, list[str]] = {
|
||||
"完成情况（自动生成）": [f"{row.get('type')}：{row.get('detail')}" for row in completion] or ["指标未配置（W1）。"],
|
||||
"叙事素材要点": [f"· {p.get('point')}（来源：{p.get('source')}）" for p in narrative_points] or ["无素材，请补录成果/年度报告摘句。"],
|
||||
"Word 初稿": [f"文件：{record.get('draft_file') or '—'}（output 目录可取）"],
|
||||
}
|
||||
draft = {
|
||||
"project_no": record.get("project_no"),
|
||||
"project_name": record.get("project_name"),
|
||||
"batch_no": record.get("batch_no"),
|
||||
"sections": sections,
|
||||
}
|
||||
html_text = build_preview_html(draft)
|
||||
path = write_html_page(f"draft-{draft_id}.html", html_text)
|
||||
log.info("preview_render_done draft_id=%s path=%s stage=render", draft_id, path)
|
||||
return path
|
||||
57
scripts/service/sibling_bridge.py
Normal file
57
scripts/service/sibling_bridge.py
Normal file
@@ -0,0 +1,57 @@
|
||||
"""兄弟技能 CLI 调用工具。
|
||||
|
||||
通过子进程调用同级其他 skill 的 main.py，并解析 JSON 输出。
|
||||
具体调用哪些兄弟技能，由复制后的业务 skill 在 service 层按需决定。
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
from typing import Any, Dict, List, Optional
|
||||
|
||||
from util.logging_config import subprocess_env_with_trace
|
||||
from util.runtime_paths import get_skills_root
|
||||
|
||||
|
||||
def call_sibling_json(skill_slug: str, args: List[str]) -> Optional[Dict[str, Any]]:
|
||||
"""通用兄弟技能调用器。
|
||||
|
||||
Args:
|
||||
skill_slug: 兄弟技能的 slug（即同级目录名）。
|
||||
args: 传给 main.py 的命令行参数列表。
|
||||
|
||||
Returns:
|
||||
若兄弟技能输出可解析的 JSON 对象则返回 dict；否则返回 None。
|
||||
"""
|
||||
script_path = os.path.join(get_skills_root(), skill_slug, "scripts", "main.py")
|
||||
if not os.path.isfile(script_path):
|
||||
return None
|
||||
proc = subprocess.run(
|
||||
[sys.executable, script_path, *args],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
encoding="utf-8",
|
||||
errors="replace",
|
||||
env=subprocess_env_with_trace(),
|
||||
)
|
||||
raw = (proc.stdout or "").strip()
|
||||
if not raw or raw.startswith("ERROR"):
|
||||
return None
|
||||
try:
|
||||
data = json.loads(raw)
|
||||
except json.JSONDecodeError:
|
||||
return None
|
||||
return data if isinstance(data, dict) else None
|
||||
|
||||
|
||||
def get_sibling_main_path(skill_slug: str) -> str:
|
||||
"""获取兄弟技能的 main.py 绝对路径。
|
||||
|
||||
使用示例（在 task_service.py 中）：
|
||||
from service.sibling_bridge import get_sibling_main_path, call_sibling_json
|
||||
result = call_sibling_json("account-manager", ["list", "--limit", "10"])
|
||||
"""
|
||||
return os.path.join(get_skills_root(), skill_slug, "scripts", "main.py")
|
||||
84
scripts/service/task_run_support.py
Normal file
84
scripts/service/task_run_support.py
Normal file
@@ -0,0 +1,84 @@
|
||||
"""任务运行辅助：录屏信息组装与 CLI 输出（通用模板，无业务逻辑）。"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any, Dict, Optional
|
||||
|
||||
|
||||
def build_video_info(
|
||||
video_summary: dict[str, Any],
|
||||
compose_context_before: Optional[dict[str, Any]] = None,
|
||||
compose_context_after: Optional[dict[str, Any]] = None,
|
||||
) -> dict[str, Any]:
|
||||
"""将 RpaVideoSession.summary() 转为 finish() / CLI 可用的 video 块。"""
|
||||
return {
|
||||
"enabled": video_summary.get("enabled", False),
|
||||
"path": video_summary.get("path"),
|
||||
"capture_path": video_summary.get("capture_path"),
|
||||
"record_log_path": video_summary.get("record_log_path"),
|
||||
"warnings": list(video_summary.get("warnings") or []),
|
||||
"voiceover_path": video_summary.get("voiceover_path"),
|
||||
"music_path": video_summary.get("music_path"),
|
||||
"audio_warnings": list(video_summary.get("audio_warnings") or []),
|
||||
"compose_context": {
|
||||
**(compose_context_before or {}),
|
||||
"after_compose": compose_context_after or {},
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
def merge_video_into_result_summary(
|
||||
payload: dict[str, Any],
|
||||
video_info: Optional[dict[str, Any]],
|
||||
) -> dict[str, Any]:
|
||||
"""把 video artifact 字段写入 finish() 结果对象（video / video_path 等）。"""
|
||||
if not video_info:
|
||||
return payload
|
||||
payload = dict(payload)
|
||||
payload["video"] = video_info
|
||||
payload["video_path"] = video_info.get("path")
|
||||
payload["raw_video"] = video_info.get("capture_path")
|
||||
payload["video_log"] = video_info.get("record_log_path")
|
||||
payload["video_warnings"] = list(video_info.get("warnings") or [])
|
||||
payload["voiceover_path"] = video_info.get("voiceover_path")
|
||||
payload["music_path"] = video_info.get("music_path")
|
||||
payload["audio_warnings"] = list(video_info.get("audio_warnings") or [])
|
||||
return payload
|
||||
|
||||
|
||||
def _print_video_summary(video_block: Optional[dict[str, Any]]) -> None:
|
||||
"""任务完成后在 CLI 打印录屏路径、日志与诊断信息。"""
|
||||
if not isinstance(video_block, dict) or not video_block.get("enabled"):
|
||||
return
|
||||
record_log = video_block.get("record_log_path")
|
||||
if record_log:
|
||||
print(f"录屏日志：{record_log}")
|
||||
path = video_block.get("path")
|
||||
if path:
|
||||
print(f"录屏路径：{path}")
|
||||
else:
|
||||
print("录屏路径：未生成")
|
||||
warnings = video_block.get("warnings") or []
|
||||
if warnings:
|
||||
print(f"视频诊断：{'; '.join(str(w) for w in warnings)}")
|
||||
capture = video_block.get("capture_path")
|
||||
if capture:
|
||||
print(f"原始录屏路径：{capture}")
|
||||
voiceover = video_block.get("voiceover_path")
|
||||
if voiceover:
|
||||
print(f"旁白路径：{voiceover}")
|
||||
music = video_block.get("music_path")
|
||||
if music:
|
||||
print(f"背景音乐：{music}")
|
||||
audio_warnings = video_block.get("audio_warnings") or []
|
||||
if audio_warnings:
|
||||
print(f"音频诊断：{'; '.join(str(w) for w in audio_warnings)}")
|
||||
compose_ctx = video_block.get("compose_context")
|
||||
if isinstance(compose_ctx, dict):
|
||||
print(
|
||||
"视频合成上下文："
|
||||
f"media_assets_root={compose_ctx.get('media_assets_root', '')}; "
|
||||
f"ffmpeg_path={compose_ctx.get('ffmpeg_path', '')}; "
|
||||
f"background_music_issue={compose_ctx.get('background_music_issue') or ''}; "
|
||||
f"background_music_sample_path={compose_ctx.get('background_music_sample_path', '')}"
|
||||
)
|
||||
625
scripts/service/task_service.py
Normal file
625
scripts/service/task_service.py
Normal file
@@ -0,0 +1,625 @@
|
||||
"""任务编排层：job_context / emit / finish、鉴权与错误转换。
|
||||
|
||||
领域业务在 ``service/draft_service.py``（初稿内核）、
|
||||
``service/ledger_service.py``（台账/记录）、``service/docx_service.py``（Word 渲染）、
|
||||
``service/report_service.py``（HTML 简报），由本模块调用；
|
||||
多入口（CLI / Action / 对话 / cron）复用同一内核，禁止按入口分叉业务。
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import json
|
||||
import os
|
||||
import uuid
|
||||
from typing import Any, Optional
|
||||
|
||||
from jiangchang_skill_core import collect_runtime_diagnostics, config, format_runtime_health_lines
|
||||
from jiangchang_skill_core.activity import JobStopped, emit, finish, job_context
|
||||
|
||||
from jiangchang_skill_core.rpa.video_session import RpaVideoSession
|
||||
from service.entitlement_service import check_entitlement
|
||||
from service.task_run_support import (
|
||||
_print_video_summary,
|
||||
build_video_info,
|
||||
merge_video_into_result_summary,
|
||||
)
|
||||
from util.constants import LOG_LOGGER_NAME, PLATFORM_KIT_MIN_VERSION, SKILL_SLUG, SKILL_VERSION
|
||||
from util.logging_config import get_skill_logger, setup_skill_logging
|
||||
from util.runtime_paths import get_db_path, get_skill_root
|
||||
from db.connection import init_db
|
||||
|
||||
|
||||
def _get_task_logger():
|
||||
try:
|
||||
return get_skill_logger()
|
||||
except RuntimeError:
|
||||
setup_skill_logging(SKILL_SLUG, LOG_LOGGER_NAME)
|
||||
return get_skill_logger()
|
||||
|
||||
|
||||
def _print_json(payload: dict[str, Any]) -> None:
|
||||
print(json.dumps(payload, ensure_ascii=False))
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# 模板演示入口（保留：满足 POLICY-RPA-003 录屏集成与 CLI run 契约；不承载本技能业务）
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
async def _run_template_demo(target: Optional[str], input_id: Optional[str]) -> tuple[int, dict[str, Any]]:
|
||||
"""最小 RpaVideoSession 示范：不启动浏览器、不执行业务，仅演示录屏包裹范式。"""
|
||||
batch_id = uuid.uuid4().hex[:12]
|
||||
data_dir = get_skill_root()
|
||||
|
||||
async with RpaVideoSession(
|
||||
skill_slug=SKILL_SLUG,
|
||||
skill_data_dir=data_dir,
|
||||
batch_id=batch_id,
|
||||
title="开始执行示例任务",
|
||||
closing_title="示例任务执行完成",
|
||||
) as video:
|
||||
video.add_step("准备执行示例任务")
|
||||
if target:
|
||||
video.add_step(f"接收目标参数：{target}")
|
||||
if input_id:
|
||||
video.add_step(f"接收输入标识：{input_id}")
|
||||
video.add_step("示例任务执行完成")
|
||||
|
||||
video_summary = video.summary()
|
||||
video_info = build_video_info(video_summary, {}, {})
|
||||
return 1, video_info
|
||||
|
||||
|
||||
def cmd_run(target: Optional[str] = None, input_id: Optional[str] = None) -> int:
|
||||
"""模板演示入口：本技能主能力请使用 broadcast 等业务命令。"""
|
||||
log = _get_task_logger()
|
||||
task_type = "demo"
|
||||
|
||||
with job_context(skill=SKILL_SLUG):
|
||||
log.info(
|
||||
"task_start task_type=%s target_id=%s input_id=%s stage=run",
|
||||
task_type,
|
||||
target,
|
||||
input_id,
|
||||
)
|
||||
emit("开始处理任务", skill=SKILL_SLUG, stage="run")
|
||||
try:
|
||||
ok, reason = check_entitlement(SKILL_SLUG)
|
||||
if not ok:
|
||||
log.warning(
|
||||
"entitlement_failed task_type=%s stage=auth error_code=ENTITLEMENT_DENIED",
|
||||
task_type,
|
||||
)
|
||||
emit("鉴权失败，已记录诊断信息", type="warn", skill=SKILL_SLUG, stage="auth")
|
||||
finish(
|
||||
status="failed",
|
||||
message=reason,
|
||||
skill=SKILL_SLUG,
|
||||
error_code="ENTITLEMENT_DENIED",
|
||||
stage="auth",
|
||||
)
|
||||
print(f"ERROR:ENTITLEMENT_DENIED {reason}")
|
||||
return 1
|
||||
|
||||
log.info("entitlement_ok task_type=%s stage=auth", task_type)
|
||||
log.info("rpa_start stage=demo_prepare task_type=%s", task_type)
|
||||
log.info("task_run_demo_start target_id=%s input_id=%s stage=demo_prepare", target, input_id)
|
||||
rc, video_info = asyncio.run(_run_template_demo(target, input_id))
|
||||
log.info("rpa_done stage=demo_prepare status=ok")
|
||||
log.info(
|
||||
"task_run_demo_done target_id=%s input_id=%s stage=demo_finish status=failed",
|
||||
target,
|
||||
input_id,
|
||||
)
|
||||
_print_video_summary(video_info)
|
||||
|
||||
summary_payload = merge_video_into_result_summary(
|
||||
{
|
||||
"template_demo": True,
|
||||
"target": target,
|
||||
"input_id": input_id,
|
||||
},
|
||||
video_info,
|
||||
)
|
||||
|
||||
log.warning(
|
||||
"task_failed task_type=%s stage=demo_finish error_code=TEMPLATE_STUB",
|
||||
task_type,
|
||||
)
|
||||
finish(
|
||||
status="failed",
|
||||
message="模板演示入口未承载本技能业务",
|
||||
skill=SKILL_SLUG,
|
||||
error_code="TEMPLATE_STUB",
|
||||
**summary_payload,
|
||||
)
|
||||
print("ERROR:TEMPLATE_STUB 这是模板演示入口，请使用 draft-report 命令生成结题报告初稿。")
|
||||
return rc
|
||||
except JobStopped:
|
||||
raise
|
||||
except Exception:
|
||||
log.exception(
|
||||
"task_failed task_type=%s target_id=%s input_id=%s",
|
||||
task_type,
|
||||
target,
|
||||
input_id,
|
||||
)
|
||||
emit("任务失败，已记录诊断信息", type="warn", skill=SKILL_SLUG, stage="run")
|
||||
finish(
|
||||
status="failed",
|
||||
message="任务执行异常，详见统一日志",
|
||||
skill=SKILL_SLUG,
|
||||
stage="run",
|
||||
)
|
||||
return 1
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# 基础命令
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def cmd_config_path() -> int:
|
||||
example_path = os.path.join(get_skill_root(), ".env.example")
|
||||
env_path = config.get_env_file_path() or ""
|
||||
_print_json(
|
||||
{
|
||||
"skill": SKILL_SLUG,
|
||||
"env_path": env_path,
|
||||
"example_path": os.path.abspath(example_path),
|
||||
}
|
||||
)
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_health() -> int:
|
||||
runtime = collect_runtime_diagnostics(
|
||||
skill_slug=SKILL_SLUG,
|
||||
platform_kit_min_version=PLATFORM_KIT_MIN_VERSION,
|
||||
skill_root=get_skill_root(),
|
||||
)
|
||||
example_path = os.path.join(get_skill_root(), ".env.example")
|
||||
env_path = config.get_env_file_path() or ""
|
||||
env_exists = bool(env_path and os.path.isfile(env_path))
|
||||
|
||||
health_status = "failed" if runtime.has_fatal_issues else "ok"
|
||||
lines = [
|
||||
f"{SKILL_SLUG} health: {health_status}",
|
||||
*format_runtime_health_lines(runtime),
|
||||
f"env_path: {env_path}",
|
||||
f"env_exists: {env_exists}",
|
||||
f"example_path: {os.path.abspath(example_path)}",
|
||||
]
|
||||
for line in lines:
|
||||
print(line)
|
||||
return 1 if runtime.has_fatal_issues else 0
|
||||
|
||||
|
||||
def cmd_version() -> int:
|
||||
_print_json({"version": SKILL_VERSION, "skill": SKILL_SLUG})
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_init_db() -> int:
|
||||
"""幂等创建/迁移本地 SQLite 与数据管理元数据（宿主 install/upgrade 可调用）。"""
|
||||
log = _get_task_logger()
|
||||
try:
|
||||
init_db()
|
||||
except Exception as exc: # noqa: BLE001 — CLI 边界，统一成可机读失败
|
||||
print(
|
||||
json.dumps(
|
||||
{"ok": False, "skill": SKILL_SLUG, "error": str(exc)},
|
||||
ensure_ascii=False,
|
||||
)
|
||||
)
|
||||
return 1
|
||||
_print_json({"ok": True, "skill": SKILL_SLUG, "db_path": get_db_path()})
|
||||
return 0
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# 台账维护
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def _parse_json_arg(raw: str, label: str) -> list[dict[str, Any]]:
|
||||
import sys
|
||||
|
||||
text = (raw or "").strip()
|
||||
if not text:
|
||||
raise ValueError(f"缺少导入 JSON（{label}）")
|
||||
if text == "-":
|
||||
text = sys.stdin.read().strip()
|
||||
elif text.startswith(("[", "{")):
|
||||
pass
|
||||
elif os.path.isfile(text):
|
||||
with open(text, encoding="utf-8") as f:
|
||||
text = f.read().strip()
|
||||
else:
|
||||
raise ValueError(f"{label} 不是有效文件路径或 JSON：{text[:80]}")
|
||||
try:
|
||||
payload = json.loads(text)
|
||||
except json.JSONDecodeError as exc:
|
||||
raise ValueError(f"导入 JSON 解析失败：{exc}") from exc
|
||||
if isinstance(payload, dict):
|
||||
for key in ("projects", "achievements", "expenses", "items"):
|
||||
if isinstance(payload.get(key), list):
|
||||
payload = payload[key]
|
||||
break
|
||||
else:
|
||||
payload = [payload]
|
||||
if not isinstance(payload, list):
|
||||
raise ValueError(f"{label} 应为对象数组")
|
||||
return payload
|
||||
|
||||
|
||||
def cmd_add_project(
|
||||
*,
|
||||
project_no: str,
|
||||
name: str = "",
|
||||
pi: str = "",
|
||||
department: str = "",
|
||||
program: str = "",
|
||||
start: str = "",
|
||||
end: str = "",
|
||||
expected_json: str = "",
|
||||
excerpt: str = "",
|
||||
status: str = "",
|
||||
) -> int:
|
||||
log = _get_task_logger()
|
||||
from service.ledger_service import upsert_project
|
||||
|
||||
with job_context(skill=SKILL_SLUG):
|
||||
log.info("task_start task_type=add_project project_no=%s stage=ledger", project_no)
|
||||
emit("开始写入结题项目", skill=SKILL_SLUG, stage="ledger")
|
||||
try:
|
||||
ok, reason = check_entitlement(SKILL_SLUG)
|
||||
if not ok:
|
||||
log.warning("entitlement_failed task_type=add_project stage=auth")
|
||||
finish(status="failed", message=reason, skill=SKILL_SLUG, error_code="ENTITLEMENT_DENIED", stage="auth")
|
||||
print(f"ERROR:ENTITLEMENT_DENIED {reason}")
|
||||
return 1
|
||||
fields: dict[str, Any] = {"project_no": project_no}
|
||||
for key, value in (("project_name", name), ("pi_name", pi), ("department", department), ("program", program), ("start_date", start), ("end_date", end), ("expected_json", expected_json), ("annual_report_excerpt", excerpt), ("status", status)):
|
||||
if value:
|
||||
fields[key] = value
|
||||
payload = upsert_project(fields)
|
||||
_print_json(payload)
|
||||
finish(status="success", message=f"项目 {project_no} 已{('更新' if payload['action'] == 'updated' else '录入')}", skill=SKILL_SLUG, stage="ledger")
|
||||
return 0
|
||||
except ValueError as exc:
|
||||
log.warning("task_failed task_type=add_project error_code=PROJECT_INVALID detail=%s", exc)
|
||||
finish(status="failed", message=str(exc), skill=SKILL_SLUG, error_code="PROJECT_INVALID", stage="ledger")
|
||||
print(f"ERROR:PROJECT_INVALID {exc}")
|
||||
return 1
|
||||
except JobStopped:
|
||||
raise
|
||||
except Exception:
|
||||
log.exception("task_failed task_type=add_project stage=ledger")
|
||||
finish(status="failed", message="项目写入异常，详见统一日志", skill=SKILL_SLUG, stage="ledger")
|
||||
return 1
|
||||
|
||||
|
||||
def cmd_add_achievement(
|
||||
*,
|
||||
project_no: str,
|
||||
ach_type: str,
|
||||
title: str,
|
||||
venue: str = "",
|
||||
date: str = "",
|
||||
representative: str = "",
|
||||
note: str = "",
|
||||
) -> int:
|
||||
log = _get_task_logger()
|
||||
from service.ledger_service import upsert_achievement
|
||||
|
||||
with job_context(skill=SKILL_SLUG):
|
||||
log.info("task_start task_type=add_achievement project_no=%s stage=ledger", project_no)
|
||||
emit("开始写入成果", skill=SKILL_SLUG, stage="ledger")
|
||||
try:
|
||||
ok, reason = check_entitlement(SKILL_SLUG)
|
||||
if not ok:
|
||||
log.warning("entitlement_failed task_type=add_achievement stage=auth")
|
||||
finish(status="failed", message=reason, skill=SKILL_SLUG, error_code="ENTITLEMENT_DENIED", stage="auth")
|
||||
print(f"ERROR:ENTITLEMENT_DENIED {reason}")
|
||||
return 1
|
||||
payload = upsert_achievement(
|
||||
{"project_no": project_no, "achievement_type": ach_type, "title": title, "venue_or_no": venue, "ach_date": date, "is_representative": representative, "note": note}
|
||||
)
|
||||
_print_json(payload)
|
||||
finish(status="success", message=f"成果已录入：{title[:20]}", skill=SKILL_SLUG, stage="ledger")
|
||||
return 0
|
||||
except ValueError as exc:
|
||||
log.warning("task_failed task_type=add_achievement error_code=PROJECT_INVALID detail=%s", exc)
|
||||
finish(status="failed", message=str(exc), skill=SKILL_SLUG, error_code="PROJECT_INVALID", stage="ledger")
|
||||
print(f"ERROR:PROJECT_INVALID {exc}")
|
||||
return 1
|
||||
except JobStopped:
|
||||
raise
|
||||
except Exception:
|
||||
log.exception("task_failed task_type=add_achievement stage=ledger")
|
||||
finish(status="failed", message="成果写入异常，详见统一日志", skill=SKILL_SLUG, stage="ledger")
|
||||
return 1
|
||||
|
||||
|
||||
def cmd_add_expense(*, project_no: str, category: str, amount: float, date: str = "", description: str = "") -> int:
|
||||
log = _get_task_logger()
|
||||
from service.ledger_service import upsert_expense
|
||||
|
||||
with job_context(skill=SKILL_SLUG):
|
||||
log.info("task_start task_type=add_expense project_no=%s stage=ledger", project_no)
|
||||
emit("开始写入决算明细", skill=SKILL_SLUG, stage="ledger")
|
||||
try:
|
||||
ok, reason = check_entitlement(SKILL_SLUG)
|
||||
if not ok:
|
||||
log.warning("entitlement_failed task_type=add_expense stage=auth")
|
||||
finish(status="failed", message=reason, skill=SKILL_SLUG, error_code="ENTITLEMENT_DENIED", stage="auth")
|
||||
print(f"ERROR:ENTITLEMENT_DENIED {reason}")
|
||||
return 1
|
||||
payload = upsert_expense({"project_no": project_no, "category": category, "amount": amount, "occurred_date": date, "description": description})
|
||||
_print_json(payload)
|
||||
finish(status="success", message=f"决算明细已录入：{category} {payload['amount']} 元", skill=SKILL_SLUG, stage="ledger")
|
||||
return 0
|
||||
except ValueError as exc:
|
||||
log.warning("task_failed task_type=add_expense error_code=PROJECT_INVALID detail=%s", exc)
|
||||
finish(status="failed", message=str(exc), skill=SKILL_SLUG, error_code="PROJECT_INVALID", stage="ledger")
|
||||
print(f"ERROR:PROJECT_INVALID {exc}")
|
||||
return 1
|
||||
except JobStopped:
|
||||
raise
|
||||
except Exception:
|
||||
log.exception("task_failed task_type=add_expense stage=ledger")
|
||||
finish(status="failed", message="决算写入异常，详见统一日志", skill=SKILL_SLUG, stage="ledger")
|
||||
return 1
|
||||
|
||||
|
||||
def cmd_import(projects_json: str = "", achievements_json: str = "", expenses_json: str = "") -> int:
|
||||
"""统一导入入口：projects/achievements/expenses 三类 JSON（至少提供一个）。"""
|
||||
log = _get_task_logger()
|
||||
from service.ledger_service import import_achievements, import_expenses, import_projects
|
||||
|
||||
with job_context(skill=SKILL_SLUG):
|
||||
log.info("task_start task_type=import stage=ledger")
|
||||
emit("开始批量导入结题数据", skill=SKILL_SLUG, stage="ledger")
|
||||
try:
|
||||
ok, reason = check_entitlement(SKILL_SLUG)
|
||||
if not ok:
|
||||
log.warning("entitlement_failed task_type=import stage=auth")
|
||||
finish(status="failed", message=reason, skill=SKILL_SLUG, error_code="ENTITLEMENT_DENIED", stage="auth")
|
||||
print(f"ERROR:ENTITLEMENT_DENIED {reason}")
|
||||
return 1
|
||||
summary: dict[str, Any] = {"ok": True}
|
||||
if projects_json:
|
||||
summary["projects"] = import_projects(_parse_json_arg(projects_json, "--projects-json"))
|
||||
if achievements_json:
|
||||
summary["achievements"] = import_achievements(_parse_json_arg(achievements_json, "--achievements-json"))
|
||||
if expenses_json:
|
||||
summary["expenses"] = import_expenses(_parse_json_arg(expenses_json, "--expenses-json"))
|
||||
if len(summary) == 1:
|
||||
raise ValueError("至少提供一个导入 JSON（--projects-json / --achievements-json / --expenses-json）")
|
||||
_print_json(summary)
|
||||
finish(status="success", message="批量导入完成", skill=SKILL_SLUG, stage="ledger")
|
||||
return 0
|
||||
except ValueError as exc:
|
||||
log.warning("task_failed task_type=import error_code=PROJECT_INVALID detail=%s", exc)
|
||||
finish(status="failed", message=str(exc), skill=SKILL_SLUG, error_code="PROJECT_INVALID", stage="ledger")
|
||||
print(f"ERROR:PROJECT_INVALID {exc}")
|
||||
return 1
|
||||
except JobStopped:
|
||||
raise
|
||||
except Exception:
|
||||
log.exception("task_failed task_type=import stage=ledger")
|
||||
finish(status="failed", message="批量导入异常，详见统一日志", skill=SKILL_SLUG, stage="ledger")
|
||||
return 1
|
||||
|
||||
|
||||
def cmd_list(kind: str = "projects", project_no: str = "", status: str = "") -> int:
|
||||
log = _get_task_logger()
|
||||
from service.ledger_service import list_achievements, list_expenses, list_projects
|
||||
|
||||
with job_context(skill=SKILL_SLUG):
|
||||
log.info("task_start task_type=list kind=%s project_no=%s", kind, project_no)
|
||||
try:
|
||||
if kind == "achievements":
|
||||
rows = list_achievements(project_no)
|
||||
elif kind == "expenses":
|
||||
rows = list_expenses(project_no)
|
||||
else:
|
||||
rows = list_projects(status=status)
|
||||
_print_json({"ok": True, "count": len(rows), "rows": rows})
|
||||
return 0
|
||||
except Exception:
|
||||
log.exception("task_failed task_type=list")
|
||||
print("ERROR:QUERY_FAILED 台账查询异常，详见统一日志")
|
||||
return 1
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# 初稿生成
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def cmd_draft_report(*, project_no: str) -> int:
|
||||
"""结题报告初稿（主命令，同步）：指定项目生成 Word 初稿 + HTML 预览。"""
|
||||
log = _get_task_logger()
|
||||
from service.draft_service import query_pending_projects, run_draft
|
||||
|
||||
with job_context(skill=SKILL_SLUG):
|
||||
log.info("task_start task_type=draft_report project_no=%s stage=draft", project_no)
|
||||
emit("开始生成结题报告初稿", skill=SKILL_SLUG, stage="draft")
|
||||
try:
|
||||
ok, reason = check_entitlement(SKILL_SLUG)
|
||||
if not ok:
|
||||
log.warning("entitlement_failed task_type=draft_report stage=auth")
|
||||
finish(status="failed", message=reason, skill=SKILL_SLUG, error_code="ENTITLEMENT_DENIED", stage="auth")
|
||||
print(f"ERROR:ENTITLEMENT_DENIED {reason}")
|
||||
return 1
|
||||
|
||||
projects = query_pending_projects(project_no=project_no)
|
||||
if not projects:
|
||||
message = f"未找到该项目（编号 {project_no}）或项目状态不是“待结题”"
|
||||
log.warning("task_failed task_type=draft_report error_code=PROJECT_NOT_FOUND stage=draft")
|
||||
finish(status="failed", message=message, skill=SKILL_SLUG, error_code="PROJECT_NOT_FOUND", stage="draft")
|
||||
print(f"ERROR:PROJECT_NOT_FOUND {message}")
|
||||
return 1
|
||||
project = projects[0]
|
||||
achievements = []
|
||||
expenses = []
|
||||
from service.ledger_service import list_achievements, list_expenses
|
||||
|
||||
achievements = list_achievements(project_no)
|
||||
expenses = list_expenses(project_no)
|
||||
|
||||
result = run_draft(project, achievements, expenses)
|
||||
_print_json(result)
|
||||
finish(
|
||||
status="success",
|
||||
message=f"初稿已生成：{result['draft_file']}",
|
||||
skill=SKILL_SLUG,
|
||||
stage="draft",
|
||||
batch_no=result["batch_no"],
|
||||
)
|
||||
return 0
|
||||
except JobStopped:
|
||||
raise
|
||||
except ValueError as exc:
|
||||
log.warning("task_failed task_type=draft_report error_code=PROJECT_INVALID detail=%s", exc)
|
||||
finish(status="failed", message=str(exc), skill=SKILL_SLUG, error_code="PROJECT_INVALID", stage="draft")
|
||||
print(f"ERROR:PROJECT_INVALID {exc}")
|
||||
return 1
|
||||
except Exception:
|
||||
log.exception("task_failed task_type=draft_report stage=draft")
|
||||
emit("初稿生成失败，已记录诊断信息", type="warn", skill=SKILL_SLUG, stage="draft")
|
||||
finish(status="failed", message="初稿生成异常，详见统一日志", skill=SKILL_SLUG, stage="draft")
|
||||
return 1
|
||||
|
||||
|
||||
def cmd_draft_batch_pending() -> int:
|
||||
"""批量初稿（async Action 入口）：为全部“待结题”项目生成初稿，任务中心可见进度。"""
|
||||
log = _get_task_logger()
|
||||
from service.draft_service import query_pending_projects, run_draft
|
||||
from service.ledger_service import list_achievements, list_expenses
|
||||
|
||||
with job_context(skill=SKILL_SLUG):
|
||||
log.info("task_start task_type=draft_batch stage=batch")
|
||||
emit("开始批量生成结题初稿", skill=SKILL_SLUG, stage="batch")
|
||||
try:
|
||||
ok, reason = check_entitlement(SKILL_SLUG)
|
||||
if not ok:
|
||||
log.warning("entitlement_failed task_type=draft_batch stage=auth")
|
||||
finish(status="failed", message=reason, skill=SKILL_SLUG, error_code="ENTITLEMENT_DENIED", stage="auth")
|
||||
print(f"ERROR:ENTITLEMENT_DENIED {reason}")
|
||||
return 1
|
||||
|
||||
projects = query_pending_projects()
|
||||
if not projects:
|
||||
message = "没有“待结题”状态的项目，批量生成跳过"
|
||||
log.warning("task_failed task_type=draft_batch error_code=PROJECT_NOT_FOUND stage=batch")
|
||||
finish(status="failed", message=message, skill=SKILL_SLUG, error_code="PROJECT_NOT_FOUND", stage="batch")
|
||||
print(f"ERROR:PROJECT_NOT_FOUND {message}")
|
||||
return 1
|
||||
|
||||
drafts = []
|
||||
for index, project in enumerate(projects, start=1):
|
||||
emit(f"[{index}/{len(projects)}] {project.get('project_name') or project.get('project_no')}", skill=SKILL_SLUG, stage="batch")
|
||||
try:
|
||||
result = run_draft(project, list_achievements(project["project_no"]), list_expenses(project["project_no"]))
|
||||
drafts.append({"draft_id": result["draft_id"], "project_no": result["project_no"], "draft_file": result["draft_file"]})
|
||||
except Exception:
|
||||
log.exception("draft_batch_item_failed project_no=%s", project.get("project_no"))
|
||||
_print_json({"ok": True, "count": len(drafts), "drafts": drafts})
|
||||
finish(status="success", message=f"批量初稿完成 {len(drafts)}/{len(projects)} 个项目", skill=SKILL_SLUG, stage="batch")
|
||||
return 0
|
||||
except JobStopped:
|
||||
raise
|
||||
except Exception:
|
||||
log.exception("task_failed task_type=draft_batch stage=batch")
|
||||
emit("批量初稿失败，已记录诊断信息", type="warn", skill=SKILL_SLUG, stage="batch")
|
||||
finish(status="failed", message="批量初稿执行异常，详见统一日志", skill=SKILL_SLUG, stage="batch")
|
||||
return 1
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# 记录与统计
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def cmd_list_drafts(limit: int = 20) -> int:
|
||||
log = _get_task_logger()
|
||||
from service.ledger_service import list_drafts
|
||||
|
||||
with job_context(skill=SKILL_SLUG):
|
||||
log.info("task_start task_type=list_drafts limit=%s", limit)
|
||||
try:
|
||||
drafts = list_drafts(limit=limit)
|
||||
_print_json({"ok": True, "count": len(drafts), "drafts": drafts})
|
||||
return 0
|
||||
except Exception:
|
||||
log.exception("task_failed task_type=list_drafts")
|
||||
print("ERROR:QUERY_FAILED 初稿记录查询异常，详见统一日志")
|
||||
return 1
|
||||
|
||||
|
||||
def cmd_show_draft(draft_id: int) -> int:
|
||||
log = _get_task_logger()
|
||||
from service.ledger_service import get_draft
|
||||
|
||||
with job_context(skill=SKILL_SLUG):
|
||||
log.info("task_start task_type=show_draft draft_id=%s", draft_id)
|
||||
try:
|
||||
draft = get_draft(int(draft_id))
|
||||
_print_json({"ok": True, "draft": draft})
|
||||
return 0
|
||||
except ValueError as exc:
|
||||
log.warning("task_failed task_type=show_draft error_code=DRAFT_NOT_FOUND detail=%s", exc)
|
||||
print(f"ERROR:DRAFT_NOT_FOUND {exc}")
|
||||
return 1
|
||||
except Exception:
|
||||
log.exception("task_failed task_type=show_draft")
|
||||
print("ERROR:QUERY_FAILED 初稿记录查询异常，详见统一日志")
|
||||
return 1
|
||||
|
||||
|
||||
def cmd_render_html(report_id: Optional[int] = None) -> int:
|
||||
log = _get_task_logger()
|
||||
from service.ledger_service import list_drafts
|
||||
from service.report_service import build_preview_for_draft_id
|
||||
|
||||
with job_context(skill=SKILL_SLUG):
|
||||
log.info("task_start task_type=render_html report_id=%s stage=render", report_id)
|
||||
try:
|
||||
if report_id:
|
||||
targets = [int(report_id)]
|
||||
else:
|
||||
targets = [d["id"] for d in list_drafts(limit=10)]
|
||||
if not targets:
|
||||
log.warning("task_failed task_type=render_html error_code=DRAFT_NOT_FOUND stage=render")
|
||||
finish(status="failed", message="暂无可重建的初稿记录", skill=SKILL_SLUG, error_code="DRAFT_NOT_FOUND", stage="render")
|
||||
print("ERROR:DRAFT_NOT_FOUND 暂无可重建的初稿记录")
|
||||
return 1
|
||||
written = [{"draft_id": did, "path": build_preview_for_draft_id(did)} for did in targets]
|
||||
_print_json({"ok": True, "count": len(written), "previews": written})
|
||||
finish(status="success", message=f"已重建 {len(written)} 份预览", skill=SKILL_SLUG, stage="render")
|
||||
return 0
|
||||
except JobStopped:
|
||||
raise
|
||||
except ValueError as exc:
|
||||
log.warning("task_failed task_type=render_html error_code=DRAFT_NOT_FOUND detail=%s", exc)
|
||||
finish(status="failed", message=str(exc), skill=SKILL_SLUG, error_code="DRAFT_NOT_FOUND", stage="render")
|
||||
print(f"ERROR:DRAFT_NOT_FOUND {exc}")
|
||||
return 1
|
||||
except Exception:
|
||||
log.exception("task_failed task_type=render_html stage=render")
|
||||
finish(status="failed", message="预览重建异常，详见统一日志", skill=SKILL_SLUG, stage="render")
|
||||
return 1
|
||||
|
||||
|
||||
def cmd_stats() -> int:
|
||||
log = _get_task_logger()
|
||||
from service.ledger_service import stats
|
||||
|
||||
with job_context(skill=SKILL_SLUG):
|
||||
log.info("task_start task_type=stats")
|
||||
try:
|
||||
_print_json(stats())
|
||||
return 0
|
||||
except Exception:
|
||||
log.exception("task_failed task_type=stats")
|
||||
print("ERROR:QUERY_FAILED 统计查询异常，详见统一日志")
|
||||
return 1
|
||||
12
scripts/util/argparse_zh.py
Normal file
12
scripts/util/argparse_zh.py
Normal file
@@ -0,0 +1,12 @@
|
||||
"""argparse 中文错误说明。"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import sys
|
||||
|
||||
|
||||
class ZhArgumentParser(argparse.ArgumentParser):
|
||||
def error(self, message: str) -> None:
|
||||
print(f"参数错误：{message}\n请执行：python main.py -h 查看帮助", file=sys.stderr)
|
||||
self.exit(2)
|
||||
19
scripts/util/config_bootstrap.py
Normal file
19
scripts/util/config_bootstrap.py
Normal file
@@ -0,0 +1,19 @@
|
||||
"""技能配置初始化：.env.example 落盘与用户 .env 缺失项合并。"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
|
||||
from jiangchang_skill_core import config
|
||||
|
||||
from util.constants import SKILL_SLUG, SKILL_VERSION
|
||||
from util.runtime_paths import get_skill_root
|
||||
|
||||
|
||||
def bootstrap_skill_config() -> str:
|
||||
"""确保用户数据目录 .env 存在，并追加 .env.example 中的新配置项。"""
|
||||
example_path = os.path.join(get_skill_root(), ".env.example")
|
||||
env_path = config.ensure_env_file(SKILL_SLUG, example_path)
|
||||
comment = f"{SKILL_SLUG} v{SKILL_VERSION}" if SKILL_VERSION else None
|
||||
config.merge_missing_env_keys(example_path, env_path, comment_skill=comment)
|
||||
return env_path
|
||||
6
scripts/util/constants.py
Normal file
6
scripts/util/constants.py
Normal file
@@ -0,0 +1,6 @@
|
||||
"""技能标识、版本与平台公共库约束（结题报告初稿助手）。"""
|
||||
|
||||
SKILL_SLUG = "draft-closing-report-default"
|
||||
SKILL_VERSION = "1.0.1"
|
||||
LOG_LOGGER_NAME = "openclaw.skill.draft_closing_report_default"
|
||||
PLATFORM_KIT_MIN_VERSION = "1.2.11"
|
||||
21
scripts/util/logging_config.py
Normal file
21
scripts/util/logging_config.py
Normal file
@@ -0,0 +1,21 @@
|
||||
"""Re-export unified logging (implementation: jiangchang_skill_core.unified_logging)."""
|
||||
|
||||
from jiangchang_skill_core.unified_logging import (
|
||||
attach_unified_file_handler,
|
||||
ensure_trace_for_process,
|
||||
get_skill_log_file_path,
|
||||
get_skill_logger,
|
||||
get_unified_logs_dir,
|
||||
setup_skill_logging,
|
||||
subprocess_env_with_trace,
|
||||
)
|
||||
|
||||
__all__ = [
|
||||
"attach_unified_file_handler",
|
||||
"ensure_trace_for_process",
|
||||
"get_skill_log_file_path",
|
||||
"get_skill_logger",
|
||||
"get_unified_logs_dir",
|
||||
"setup_skill_logging",
|
||||
"subprocess_env_with_trace",
|
||||
]
|
||||
155
scripts/util/runtime_paths.py
Normal file
155
scripts/util/runtime_paths.py
Normal file
@@ -0,0 +1,155 @@
|
||||
"""数据根、技能目录、兄弟技能根路径与用户数据子目录解析。"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
|
||||
from jiangchang_skill_core.runtime_env import get_data_root, get_sibling_skills_root, get_user_id
|
||||
|
||||
from util.constants import SKILL_SLUG
|
||||
|
||||
_SCRIPTS_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
# 用户可见的上行/下行目录（数据管理「输入/输出」文件浏览器）
|
||||
STANDARD_SUBDIR_INPUT = "input"
|
||||
STANDARD_SUBDIR_OUTPUT = "output"
|
||||
|
||||
# 宿主扫描的 HTML 报告页（数据管理侧栏 htmlPages，非 input/output 文件浏览器）
|
||||
STANDARD_SUBDIR_HTML = "html"
|
||||
|
||||
# 内部/可选目录（不上侧栏）
|
||||
STANDARD_SUBDIR_UPLOADS = "uploads"
|
||||
STANDARD_SUBDIR_CACHE = "cache"
|
||||
STANDARD_SUBDIR_TEMP = "temp"
|
||||
STANDARD_SUBDIR_RPA_ARTIFACTS = "rpa-artifacts"
|
||||
STANDARD_SUBDIR_VIDEOS = "videos"
|
||||
|
||||
CONFIG_KEY_INPUT_DIR = "SKILL_INPUT_DIR"
|
||||
CONFIG_KEY_OUTPUT_DIR = "SKILL_OUTPUT_DIR"
|
||||
CONFIG_KEY_UPLOAD_DIR = "SKILL_UPLOAD_DIR"
|
||||
CONFIG_KEY_CACHE_DIR = "SKILL_CACHE_DIR"
|
||||
CONFIG_KEY_TEMP_DIR = "SKILL_TEMP_DIR"
|
||||
|
||||
|
||||
def get_skill_root() -> str:
|
||||
return os.path.dirname(_SCRIPTS_DIR)
|
||||
|
||||
|
||||
def get_openclaw_root() -> str:
|
||||
return get_sibling_skills_root(_SCRIPTS_DIR)
|
||||
|
||||
|
||||
def get_skills_root() -> str:
|
||||
return get_sibling_skills_root(_SCRIPTS_DIR)
|
||||
|
||||
|
||||
def get_skill_data_dir() -> str:
|
||||
path = os.path.join(get_data_root(), get_user_id(), SKILL_SLUG)
|
||||
os.makedirs(path, exist_ok=True)
|
||||
return path
|
||||
|
||||
|
||||
def get_db_path(filename: str | None = None) -> str:
|
||||
name = filename or f"{SKILL_SLUG}.db"
|
||||
return os.path.join(get_skill_data_dir(), name)
|
||||
|
||||
|
||||
def _normalize_subdir(value: str) -> str:
|
||||
cleaned = value.strip().strip("/\\")
|
||||
if not cleaned or cleaned.startswith(".."):
|
||||
raise ValueError(f"invalid skill data subdir: {value!r}")
|
||||
return cleaned.replace("/", os.sep).replace("\\", os.sep)
|
||||
|
||||
|
||||
def resolve_data_path(
|
||||
config_key: str | None,
|
||||
default_subdir: str,
|
||||
*,
|
||||
create: bool = True,
|
||||
) -> str:
|
||||
"""解析技能拥有路径：空配置 → 数据目录下 default_subdir；相对 → 相对数据目录；绝对 → 原样。"""
|
||||
from jiangchang_skill_core import config
|
||||
|
||||
base = get_skill_data_dir()
|
||||
raw = (config.get(config_key) or "").strip() if config_key else ""
|
||||
if not raw:
|
||||
path = os.path.join(base, _normalize_subdir(default_subdir))
|
||||
elif os.path.isabs(raw):
|
||||
path = os.path.abspath(os.path.expanduser(raw))
|
||||
else:
|
||||
path = os.path.join(base, _normalize_subdir(raw))
|
||||
|
||||
if create:
|
||||
os.makedirs(path, exist_ok=True)
|
||||
return path
|
||||
|
||||
|
||||
def resolve_input_path(raw_path: str, *, create_parent: bool = False) -> str:
|
||||
"""解析 CLI 输入路径：绝对路径原样；相对路径相对 {skill_data_dir}/input/。"""
|
||||
text = (raw_path or "").strip()
|
||||
if not text:
|
||||
return text
|
||||
expanded = os.path.expanduser(text)
|
||||
if os.path.isabs(expanded):
|
||||
return os.path.abspath(expanded)
|
||||
input_dir = get_input_dir(create=create_parent)
|
||||
return os.path.abspath(os.path.join(input_dir, os.path.normpath(expanded)))
|
||||
|
||||
|
||||
def get_input_dir(*, create: bool = True) -> str:
|
||||
"""上行：用户/Agent 放入的待处理文件（清单、CSV、产品表等）。"""
|
||||
return resolve_data_path(CONFIG_KEY_INPUT_DIR, STANDARD_SUBDIR_INPUT, create=create)
|
||||
|
||||
|
||||
def get_output_dir(*, create: bool = True) -> str:
|
||||
"""下行：技能/宿主交给用户拿走的文件（视频、报表、导出 CSV 等）。"""
|
||||
return resolve_data_path(CONFIG_KEY_OUTPUT_DIR, STANDARD_SUBDIR_OUTPUT, create=create)
|
||||
|
||||
|
||||
def get_uploads_dir(*, create: bool = True) -> str:
|
||||
return resolve_data_path(CONFIG_KEY_UPLOAD_DIR, STANDARD_SUBDIR_UPLOADS, create=create)
|
||||
|
||||
|
||||
def get_cache_dir(*, create: bool = True) -> str:
|
||||
return resolve_data_path(CONFIG_KEY_CACHE_DIR, STANDARD_SUBDIR_CACHE, create=create)
|
||||
|
||||
|
||||
def get_temp_dir(*, create: bool = True) -> str:
|
||||
return resolve_data_path(CONFIG_KEY_TEMP_DIR, STANDARD_SUBDIR_TEMP, create=create)
|
||||
|
||||
|
||||
def get_rpa_artifacts_dir(batch_id: str, *, create: bool = True) -> str:
|
||||
batch = (batch_id or "").strip() or "default"
|
||||
path = os.path.join(get_skill_data_dir(), STANDARD_SUBDIR_RPA_ARTIFACTS, batch)
|
||||
if create:
|
||||
os.makedirs(path, exist_ok=True)
|
||||
return path
|
||||
|
||||
|
||||
def get_videos_dir(*, create: bool = True) -> str:
|
||||
path = os.path.join(get_skill_data_dir(), STANDARD_SUBDIR_VIDEOS)
|
||||
if create:
|
||||
os.makedirs(path, exist_ok=True)
|
||||
return path
|
||||
|
||||
|
||||
def get_html_dir(*, create: bool = True) -> str:
|
||||
"""HTML 报告页目录：宿主扫描 `{skill_data}/html/*.html`（一层、非递归）。"""
|
||||
path = os.path.join(get_skill_data_dir(), STANDARD_SUBDIR_HTML)
|
||||
if create:
|
||||
os.makedirs(path, exist_ok=True)
|
||||
return path
|
||||
|
||||
|
||||
def list_resolved_data_paths() -> dict[str, str]:
|
||||
"""供 health / config-path 输出已解析的数据子目录（不创建目录）。"""
|
||||
return {
|
||||
"skill_data_dir": get_skill_data_dir(),
|
||||
"input_dir": get_input_dir(create=False),
|
||||
"output_dir": get_output_dir(create=False),
|
||||
"html_dir": get_html_dir(create=False),
|
||||
"uploads_dir": get_uploads_dir(create=False),
|
||||
"cache_dir": get_cache_dir(create=False),
|
||||
"temp_dir": get_temp_dir(create=False),
|
||||
"videos_dir": get_videos_dir(create=False),
|
||||
}
|
||||
227
scripts/util/slug_naming.py
Normal file
227
scripts/util/slug_naming.py
Normal file
@@ -0,0 +1,227 @@
|
||||
"""技能 slug 语义校验（verb-noun-platform 规范，见 development/NAMING.md）。"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import re
|
||||
|
||||
_KEBAB_SLUG = re.compile(r"^[a-z0-9]+(?:-[a-z0-9]+)*$")
|
||||
_MAX_SLUG_LENGTH = 48
|
||||
_MIN_SEGMENTS = 3
|
||||
_MAX_SEGMENTS = 5
|
||||
_MAX_NOUN_SEGMENTS = 3
|
||||
|
||||
_SKILL_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||||
_NAMING_DIR = os.path.join(_SKILL_ROOT, "assets", "naming")
|
||||
|
||||
_BUILTIN_VERBS = frozenset(
|
||||
{
|
||||
"scrape",
|
||||
"receive",
|
||||
"download",
|
||||
"export",
|
||||
"add",
|
||||
"fill",
|
||||
"enter",
|
||||
"bind",
|
||||
"withdraw",
|
||||
"reconcile",
|
||||
"verify",
|
||||
"submit",
|
||||
"query",
|
||||
"process",
|
||||
"reply",
|
||||
"generate",
|
||||
"draft",
|
||||
"review",
|
||||
"confirm",
|
||||
"track",
|
||||
"upload",
|
||||
"match",
|
||||
"triage",
|
||||
"ship",
|
||||
"reprice",
|
||||
}
|
||||
)
|
||||
_BUILTIN_PLATFORMS = frozenset(
|
||||
{
|
||||
"amazon",
|
||||
"shopee",
|
||||
"xinghang",
|
||||
"alibaba",
|
||||
"kingdee",
|
||||
"icbc",
|
||||
"pingpong",
|
||||
"worldfirst",
|
||||
"paypal",
|
||||
"lianlian",
|
||||
"single-window",
|
||||
"export-rebate",
|
||||
"etax",
|
||||
}
|
||||
)
|
||||
_BUILTIN_SCOPES = frozenset({"all", "batch", "multi", "default"})
|
||||
|
||||
LEGACY_EXEMPT_SLUGS: frozenset[str] = frozenset(
|
||||
{
|
||||
"account-manager",
|
||||
"skill-template",
|
||||
"your-skill-slug",
|
||||
"your_skill_slug",
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
def load_wordlist(filename: str) -> frozenset[str]:
|
||||
"""从 assets/naming/{filename} 加载词表；文件不存在时 fallback 内置集合。"""
|
||||
fallbacks = {
|
||||
"verbs.txt": _BUILTIN_VERBS,
|
||||
"platforms.txt": _BUILTIN_PLATFORMS,
|
||||
"scopes.txt": _BUILTIN_SCOPES,
|
||||
}
|
||||
fallback = fallbacks.get(filename, frozenset())
|
||||
path = os.path.join(_NAMING_DIR, filename)
|
||||
if not os.path.isfile(path):
|
||||
return fallback
|
||||
words: set[str] = set()
|
||||
with open(path, encoding="utf-8") as f:
|
||||
for line in f:
|
||||
word = line.strip()
|
||||
if word and not word.startswith("#"):
|
||||
words.add(word)
|
||||
return frozenset(words) if words else fallback
|
||||
|
||||
|
||||
def parse_slug_segments(slug: str) -> list[str]:
|
||||
"""按 '-' 分割；非法字符由上层 kebab 校验处理。"""
|
||||
slug = slug.strip()
|
||||
if not slug:
|
||||
return []
|
||||
return slug.split("-")
|
||||
|
||||
|
||||
def _match_platform_suffix(
|
||||
segments: list[str],
|
||||
platforms: frozenset[str],
|
||||
) -> tuple[str, int] | None:
|
||||
"""返回 (platform_name, platform_part_count) 或 None。"""
|
||||
for platform in sorted(platforms, key=lambda item: (-item.count("-"), item)):
|
||||
parts = platform.split("-")
|
||||
part_count = len(parts)
|
||||
if len(segments) < part_count + 2:
|
||||
continue
|
||||
if segments[-part_count:] == parts:
|
||||
return platform, part_count
|
||||
return None
|
||||
|
||||
|
||||
def classify_slug_form(segments: list[str], *, slug: str = "") -> str:
|
||||
"""
|
||||
返回: 'legacy_exempt' | 'standard' | 'scope' | 'invalid'
|
||||
|
||||
- legacy_exempt: slug in LEGACY_EXEMPT_SLUGS
|
||||
- standard: 末段匹配 platforms, 首段 in verbs, 3<=len<=5
|
||||
- scope: 末段 in scopes, 首段 in verbs, 3<=len<=5
|
||||
- invalid: 其他
|
||||
"""
|
||||
if slug in LEGACY_EXEMPT_SLUGS:
|
||||
return "legacy_exempt"
|
||||
|
||||
if not segments or not (_MIN_SEGMENTS <= len(segments) <= _MAX_SEGMENTS):
|
||||
return "invalid"
|
||||
|
||||
verbs = load_wordlist("verbs.txt")
|
||||
platforms = load_wordlist("platforms.txt")
|
||||
scopes = load_wordlist("scopes.txt")
|
||||
|
||||
if segments[0] not in verbs:
|
||||
return "invalid"
|
||||
|
||||
if segments[-1] in scopes:
|
||||
return "scope"
|
||||
|
||||
if _match_platform_suffix(segments, platforms) is not None:
|
||||
return "standard"
|
||||
|
||||
return "invalid"
|
||||
|
||||
|
||||
def validate_slug_semantics(
|
||||
slug: str,
|
||||
*,
|
||||
strict: bool = True,
|
||||
) -> tuple[list[str], list[str]]:
|
||||
"""返回 (errors, warnings)。"""
|
||||
slug = slug.strip()
|
||||
if slug in LEGACY_EXEMPT_SLUGS:
|
||||
return [], []
|
||||
|
||||
errors: list[str] = []
|
||||
warnings: list[str] = []
|
||||
|
||||
if not _KEBAB_SLUG.fullmatch(slug):
|
||||
msg = f"slug 必须为 kebab-case（小写字母、数字、连字符）：{slug!r}"
|
||||
(errors if strict else warnings).append(msg)
|
||||
return errors, warnings
|
||||
|
||||
if len(slug) > _MAX_SLUG_LENGTH:
|
||||
msg = f"slug 长度不得超过 {_MAX_SLUG_LENGTH} 字符（当前 {len(slug)}）：{slug!r}"
|
||||
(errors if strict else warnings).append(msg)
|
||||
|
||||
segments = parse_slug_segments(slug)
|
||||
segment_count = len(segments)
|
||||
|
||||
if segment_count < _MIN_SEGMENTS:
|
||||
msg = (
|
||||
f"slug 段数应为 {_MIN_SEGMENTS}～{_MAX_SEGMENTS}（verb-noun-platform），"
|
||||
f"当前为 {segment_count} 段：{slug!r}；新技能禁止 2 段无平台形态（如 reconcile-finance）"
|
||||
)
|
||||
(errors if strict else warnings).append(msg)
|
||||
return errors, warnings
|
||||
|
||||
if segment_count > _MAX_SEGMENTS:
|
||||
msg = f"slug 段数不得超过 {_MAX_SEGMENTS}（当前 {segment_count}）：{slug!r}"
|
||||
(errors if strict else warnings).append(msg)
|
||||
|
||||
verbs = load_wordlist("verbs.txt")
|
||||
platforms = load_wordlist("platforms.txt")
|
||||
scopes = load_wordlist("scopes.txt")
|
||||
|
||||
if segments[0] in platforms and segments[0] not in verbs:
|
||||
msg = f"平台名不应放在 slug 最前：{slug!r}（应为 verb-noun-platform）"
|
||||
(errors if strict else warnings).append(msg)
|
||||
|
||||
if segments[0] not in verbs:
|
||||
msg = f"slug 首段应为动词白名单中的词：{segments[0]!r}（slug={slug!r}）"
|
||||
(errors if strict else warnings).append(msg)
|
||||
|
||||
form = classify_slug_form(segments, slug=slug)
|
||||
if form == "scope":
|
||||
if segments[-1] not in scopes:
|
||||
msg = f"slug 末段应为 scope 白名单中的词：{segments[-1]!r}（slug={slug!r}）"
|
||||
(errors if strict else warnings).append(msg)
|
||||
noun_count = segment_count - 2
|
||||
elif form == "standard":
|
||||
platform_match = _match_platform_suffix(segments, platforms)
|
||||
if platform_match is None:
|
||||
msg = f"slug 末段应匹配平台白名单：{slug!r}"
|
||||
(errors if strict else warnings).append(msg)
|
||||
noun_count = 0
|
||||
else:
|
||||
_platform_name, platform_part_count = platform_match
|
||||
noun_count = segment_count - 1 - platform_part_count
|
||||
else:
|
||||
if segment_count >= _MIN_SEGMENTS:
|
||||
if segments[-1] not in scopes:
|
||||
platform_match = _match_platform_suffix(segments, platforms)
|
||||
if platform_match is None:
|
||||
msg = f"slug 末段应匹配平台或 scope 白名单：{slug!r}"
|
||||
(errors if strict else warnings).append(msg)
|
||||
noun_count = 0
|
||||
|
||||
if noun_count > _MAX_NOUN_SEGMENTS:
|
||||
warnings.append(
|
||||
f"slug 中间名词段建议不超过 {_MAX_NOUN_SEGMENTS} 个词（当前 {noun_count}）：{slug!r}"
|
||||
)
|
||||
|
||||
return errors, warnings
|
||||
20
scripts/util/timeutil.py
Normal file
20
scripts/util/timeutil.py
Normal file
@@ -0,0 +1,20 @@
|
||||
"""时间戳与 ISO 展示。"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import time
|
||||
from datetime import datetime
|
||||
from typing import Optional
|
||||
|
||||
|
||||
def now_unix() -> int:
|
||||
return int(time.time())
|
||||
|
||||
|
||||
def unix_to_iso(ts: Optional[int]) -> Optional[str]:
|
||||
if ts is None:
|
||||
return None
|
||||
try:
|
||||
return datetime.fromtimestamp(int(ts)).isoformat(timespec="seconds")
|
||||
except (ValueError, OSError, OverflowError):
|
||||
return None
|
||||
Reference in New Issue
Block a user