TacitLab/stockbuddy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add account-aware execution constraints

Browse Source
This commit is contained in:
root
2026-04-02 01:26:10 +08:00
parent fbe69ab70e
commit 5d2482c9ba
3 changed files with 514 additions and 141 deletions
Download Patch File Download Diff File Expand all files Collapse all files

203
SKILL.md
View File

@@ -1,143 +1,176 @@
---
name: stockbuddy
description: 多市场股票分析助手，提供 A 股、港股、美股的技术面和基础估值分析，给出买入/卖出操作建议。支持单只股票查询分析、持仓批量分析、关注股票管理和持仓管理。当用户提到股票分析、持仓分析、关注股票、买入建议、卖出建议，或直接提供股票代码 / 股票名称请求分析时触发此技能。
description: Multi-market stock analysis and portfolio execution assistant for CN, HK, and US equities. Provides technical + basic valuation analysis, portfolio review, account-aware position tracking, cash balances by market/currency, and execution-aware suggestions that respect lot size, odd-lot support, and trading constraints. Use when the user asks for stock analysis, portfolio analysis, buy/sell advice, watchlist management, position management, account cash tracking, rebalancing, or practical trading actions for a stock code or company name.
---
# 多市场股票分析助手 (StockBuddy)
# StockBuddy
## 概述
## Overview
A 股、港股、美股的技术面与基础估值综合分析工具，输出量化评分和明确操作建议（强烈买入/买入/持有/卖出/强烈卖出）。默认以**决策优先**的方式返回结果：先给简明结论、评分/置信度、事件修正后的二次建议与挂单实操建议；只有在用户明确要求时才展开完整长报告。
StockBuddy is a stock analysis and portfolio execution support skill for A-share, Hong Kong, and US equities. It outputs quantified scores and clear action labels (Strong Buy / Buy / Hold / Sell / Strong Sell). By default, responses are **decision-first**: give the concise conclusion, score/confidence, event-adjusted second-pass suggestion, and practical order ideas before expanding into a long-form report.
四大核心场景：
1. **单只股票分析** — 对指定股票进行完整技术面+基本面分析，给出操作建议
2. **持仓批量分析** — 对用户所有持仓股票批量分析，给出各股操作建议和整体盈亏统计
3. **持仓管理** — 增删改查持仓记录
4. **关注池管理** — 增删改查关注股票，并记录股票基本信息
**Design principle: separate durable facts from real-time derived values.**
- **Persist durable facts**: share count, cost basis, account, cash balance, market/currency, lot size, odd-lot support, and other user-confirmed trading constraints
- **Compute in real time**: latest price, market value, position weight, unrealized P&L, executable buy/sell size, and whether partial selling is actually possible
- Do **not** write latest price, position weight, or unrealized P&L back as durable truth in the database; compute them during analysis to avoid stale data and hallucination drift
## 环境准备
Five core scenarios:
1. **Single-stock analysis** — Analyze one stock with technical + basic valuation signals and produce an action recommendation
2. **Batch portfolio analysis** — Analyze all current positions and summarize both stock-level actions and overall portfolio status
3. **Position management** — Add, update, remove, and inspect positions
4. **Account and allocation management** — Track account, cash, market/currency, and use them to compute position weights and execution constraints
5. **Watchlist management** — Add, remove, and inspect watched stocks while storing basic stock metadata and trading rules
仅在依赖缺失，或脚本运行时报缺包错误时，再执行安装脚本：
## Environment Setup
Only install dependencies when they are actually missing, or when a script fails with a missing-package error:
```bash
bash {{SKILL_DIR}}/scripts/install_deps.sh
```
所需依赖：`numpy`、`pandas`、Python 内置 `sqlite3`（无需 yfinance，已改用腾讯财经数据源）
Required dependencies: `numpy`, `pandas`, built-in Python `sqlite3`.
No `yfinance` dependency is required; the current implementation mainly uses Tencent Finance data.
## 核心工作流
## Core Workflow
### 场景一：分析单只股票
### Scenario 1: Analyze a Single Stock
触发示例："分析腾讯"、"这只股票能不能买"、"看看比亚迪怎么样"、"帮我分析一下这只票"
Trigger examples: "analyze Tencent", "can I buy this stock", "look at BYD", "analyze this ticker"
**步骤：**
**Steps:**
1. **识别股票代码**
- 港股：标准化为 `XXXX.HK`
- A 股：标准化为 `SH600519` / `SZ000001`
- 美股：标准化为 `AAPL` / `TSLA`
- 用户提供中文名称时，可先根据上下文判断市场；无法唯一匹配时再向用户确认
1. **Normalize the stock code**
- Hong Kong stocks: normalize to `XXXX.HK`
- A-shares: normalize to `SH600519` / `SZ000001`
- US stocks: normalize to `AAPL` / `TSLA`
- If the user provides only a company name, infer the market from context first; ask for confirmation only if the mapping is ambiguous
2. **执行分析脚本**
2. **Run the analysis script**
```bash
python3 {{SKILL_DIR}}/scripts/analyze_stock.py <代码> --period 6mo
python3 {{SKILL_DIR}}/scripts/analyze_stock.py <CODE> --period 6mo
```
可选周期参数：`1mo` / `3mo` / `6mo`（默认）/ `1y` / `2y` / `5y`
Optional period values: `1mo` / `3mo` / `6mo` (default) / `1y` / `2y` / `5y`
**数据与缓存机制**：原始日线 K 线、关注池、持仓数据统一保存在 `~/.stockbuddy/stockbuddy.db`（SQLite）。持仓记录通过 `watchlist_id` 关联关注股票主键。分析结果单独写入 SQLite 缓存表，默认 TTL 为 10 分钟，写入时自动清理过期缓存，并将总缓存条数控制在 1000 条以内。若用户明确要求"刷新数据"或"重新分析"，加 `--no-cache` 参数强制刷新。清除分析缓存：`--clear-cache`。
**Data and caching behavior**:
- Raw daily K-line data, watchlist data, and portfolio data are stored in `~/.stockbuddy/stockbuddy.db` (SQLite)
- Positions are linked through `watchlist_id`
- Analysis results are cached separately in SQLite with a default TTL of 10 minutes
- Cache cleanup runs automatically and total cached analysis rows are capped
- If the user explicitly asks to "refresh data" or "reanalyze", add `--no-cache`
- To clear analysis cache: `--clear-cache`
3. **解读并呈现结果**
- 脚本输出 JSON 格式分析数据
- **默认单股分析优先使用** `references/output_templates.md` 中的 **“默认查询模板”**：先返回最重要的决策信息，必须包含：股票基本信息、基于数据面的操作建议（含评分与置信度）、重要事件、事件加持后的二次分析建议，以及最终的挂单实操建议
- **挂单风格默认走平衡型**：若用户未特别指定，挂单价格按 `references/output_templates.md` 中的“挂单价格生成规范”采用平衡型；只有当用户明确要求“保守版”或“激进版”时才切换
- **完整报告仅在用户明确要求时输出**：当用户说"完整报告"、"详细分析"、"完整分析详情"、"全量报告"等，再按同文件中的 **“完整报告组合规则”**，用多个原子模板拼装完整报告
- **顶部完整分析详情为必选项**：无论默认查询还是完整报告，都必须先给出 2-4 句话的自然语言完整分析详情，概括市场场景、主建议、置信度、支撑/风险点，以及是否适合立刻操作
- **仅当用户明确追问细节时**（如"展开讲讲"、"为什么是这个评级"、"短线怎么看"、"止盈止损怎么设"、"详细分析"），才切换为更自然的开放式解读，围绕用户追问点展开说明
- 最终结果直接输出为标准 Markdown 正文，不要包在代码块里；默认优先短段落、项目符号和卡片式结构，除非用户明确要求，否则不要自动展开过多宽表格
3. **Interpret and present the result**
- The script returns JSON analysis data
- **For default single-stock requests**, use the **default query template** in `references/output_templates.md`
- The default response must include: stock basics, data-driven action recommendation (with score and confidence), important events, event-adjusted second-pass suggestion, and practical order ideas
- **Default order style = balanced**. Only switch when the user explicitly asks for a conservative or aggressive version
- **Only produce the full report when explicitly requested** with phrases like "full report", "detailed analysis", or "complete analysis"
- **The top natural-language summary is mandatory** in both short and long versions: 2-4 sentences covering regime, main recommendation, confidence, support/risk points, and whether the stock is actionable today
- **Only expand into a more open-ended explanation when the user asks for detail** such as "explain why", "show the reasoning", "how about short-term", or "what stop-loss/stop-profit should I use"
- Final output must be normal Markdown, not wrapped in code fences; prefer short paragraphs, bullet points, and card-style formatting over wide tables unless the user explicitly wants a detailed report
### 场景二：持仓批量分析
### Scenario 2: Batch Portfolio Analysis
触发示例："分析我的持仓"、"看看我的股票"、"持仓怎么样了"
Trigger examples: "analyze my portfolio", "look at my holdings", "how are my positions doing"
默认输出仍以**决策优先**为主：每只持仓先给操作建议、评分/置信度、重要事件、事件修正后的二次建议，以及最简挂单实操版；除非用户明确要求详细版，否则不要把每只股票都展开成冗长全量报告。
Default output should still be **decision-first**: for each position, give the action label, score/confidence, important events, event-adjusted second suggestion, and a compact practical order version. Do not expand every holding into a full long report unless the user explicitly wants a detailed version.
**步骤：**
**Execution realism matters more than surface correctness.** When producing portfolio advice, always consider account cash, market/currency, lot size, odd-lot support, and current share count. If the user holds only one lot and odd-lot selling is not supported, do **not** suggest "trim a little" or "sell half". Instead, output only truly executable actions such as "hold" or "sell the full lot".
1. **检查持仓数据**
**Steps:**
1. **Check portfolio data**
```bash
python3 {{SKILL_DIR}}/scripts/portfolio_manager.py list
```
持仓数据保存在 `~/.stockbuddy/stockbuddy.db` 的 `positions` 表。
Portfolio data is stored in the `positions` table in `~/.stockbuddy/stockbuddy.db`.
2. **持仓为空时** → 引导用户添加持仓（参见场景三的添加操作）
2. **If the portfolio is empty** → guide the user to add positions first (see Scenario 3)
3. **执行批量分析**
3. **Run batch analysis**
```bash
python3 {{SKILL_DIR}}/scripts/portfolio_manager.py analyze
```
4. **解读并呈现结果**
- 按 `references/output_templates.md` 中"持仓批量分析报告"模板呈现
- 直接输出为标准 Markdown 正文，不要包在代码块里；可使用规范 Markdown 表格与列表混合呈现，保证不同平台可读性
- 包含每只股票的操作建议和整体盈亏汇总
4. **Interpret and present the result**
- Format the result using the "Portfolio Batch Analysis Report" section in `references/output_templates.md`
- Output normal Markdown, not code fences
- It may use standard Markdown tables mixed with lists when helpful, but keep it readable on chat surfaces
- Include stock-level recommendations and portfolio-level P&L summary
- Prefer **real-time computed fields** in the output: latest price, market value, unrealized P&L, position weight, and executable action constraints such as whole-lot vs odd-lot behavior
- Do **not** write latest price, position weight, or unrealized P&L back into durable storage; the database should only hold stable user-confirmed facts and trading rules
### 场景三：持仓管理
### Scenario 3: Position Management
触发示例："添加腾讯持仓"、"我买了 100 股比亚迪"、"删除阿里持仓"
Trigger examples: "add a Tencent position", "I bought 100 shares of BYD", "remove Alibaba from my holdings"
| 操作 | 命令 |
| Action | Command |
|------|------|
| 添加 | `python3 {{SKILL_DIR}}/scripts/portfolio_manager.py add <代码> --price <买入价> --shares <数量> [--date <日期>] [--note <备注>]` |
| 查看 | `python3 {{SKILL_DIR}}/scripts/portfolio_manager.py list` |
| 更新 | `python3 {{SKILL_DIR}}/scripts/portfolio_manager.py update <代码> [--price <价格>] [--shares <数量>] [--note <备注>]` |
| 移除 | `python3 {{SKILL_DIR}}/scripts/portfolio_manager.py remove <代码>` |
| Add position | `python3 {{SKILL_DIR}}/scripts/portfolio_manager.py add <CODE> --price <BUY_PRICE> --shares <SHARES> [--date <DATE>] [--note <NOTE>] [--account <ACCOUNT_NAME_OR_ID>]` |
| List positions | `python3 {{SKILL_DIR}}/scripts/portfolio_manager.py list` |
| Update position | `python3 {{SKILL_DIR}}/scripts/portfolio_manager.py update <CODE> [--price <PRICE>] [--shares <SHARES>] [--note <NOTE>] [--account <ACCOUNT_NAME_OR_ID>]` |
| Remove position | `python3 {{SKILL_DIR}}/scripts/portfolio_manager.py remove <CODE>` |
| List accounts | `python3 {{SKILL_DIR}}/scripts/portfolio_manager.py account-list` |
| Create/update account | `python3 {{SKILL_DIR}}/scripts/portfolio_manager.py account-upsert <ACCOUNT_NAME> [--market <MARKET>] [--currency <CURRENCY>] [--cash <TOTAL_CASH>] [--available-cash <AVAILABLE_CASH>] [--note <NOTE>]` |
| Set trading rule | `python3 {{SKILL_DIR}}/scripts/portfolio_manager.py rule-set <CODE> [--lot-size <LOT_SIZE>] [--tick-size <TICK_SIZE>] [--odd-lot]` |
添加持仓时会自动确保该股票存在于关注池，并通过 `positions.watchlist_id -> watchlist.id` 关联。若用户未提供日期，默认使用当天日期。若用户提供了自然语言信息（如"我上周花 350 买了 100 股腾讯"），提取价格、数量、日期等参数后执行命令。
When adding a position, ensure the stock exists in the watchlist and is linked through `positions.watchlist_id -> watchlist.id`. If the user does not provide a date, default to the current date. If the user provides natural-language trade info such as "I bought 100 shares of Tencent last week at 350", extract price, share count, date, and account info where possible, then execute the appropriate command.
### 场景四：关注池管理
### Scenario 4: Account and Allocation Management
触发示例："关注腾讯"、"把苹果加到关注列表"、"取消关注茅台"
Trigger examples: "my HK account has 3000 HKD cash", "track available cash", "record this under my US account", "how concentrated is my portfolio"
| 操作 | 命令 |
**Rules:**
- Keep cash, account, market, and currency as durable facts
- Keep position weights, market value, and unrealized P&L as computed fields
- If the user has multiple markets or currencies, treat them as separate account contexts unless the user explicitly wants cross-account aggregation
- Use account information to improve practical trading advice: whether the user can afford a new lot, whether a rebalance is even possible, and whether the trade would increase concentration too much
### Scenario 5: Watchlist Management
Trigger examples: "watch Tencent", "add Apple to my watchlist", "remove Moutai from watchlist"
| Action | Command |
|------|------|
| 查看关注池 | `python3 {{SKILL_DIR}}/scripts/portfolio_manager.py watch-list` |
| 添加关注 | `python3 {{SKILL_DIR}}/scripts/portfolio_manager.py watch-add <代码>` |
| 取消关注 | `python3 {{SKILL_DIR}}/scripts/portfolio_manager.py watch-remove <代码>` |
| List watchlist | `python3 {{SKILL_DIR}}/scripts/portfolio_manager.py watch-list` |
| Add watch item | `python3 {{SKILL_DIR}}/scripts/portfolio_manager.py watch-add <CODE>` |
| Remove watch item | `python3 {{SKILL_DIR}}/scripts/portfolio_manager.py watch-remove <CODE>` |
## Analysis Methodology
## 分析方法论
The scoring system combines technicals (roughly 60% weight) and basic valuation (roughly 40% weight). Final score range is approximately -10 to +10:
综合评分体系覆盖技术面（约 60% 权重）和基本面（约 40% 权重），最终评分范围约 -10 到 +10：
| 评分区间 | 操作建议 |
| Score Range | Recommendation |
|----------|----------|
| ≥ 5 | 🟢🟢 强烈买入 |
| 2 ~ 4 | 🟢 买入 |
| -1 ~ 1 | 🟡 持有/观望 |
| -4 ~ -2 | 🔴 卖出 |
| ≤ -5 | 🔴🔴 强烈卖出 |
| ≥ 5 | 🟢🟢 Strong Buy |
| 2 ~ 4 | 🟢 Buy |
| -1 ~ 1 | 🟡 Hold / Watch |
| -4 ~ -2 | 🔴 Sell |
| ≤ -5 | 🔴🔴 Strong Sell |
仅当用户要求解释评分逻辑、技术指标含义，或你需要校准开放式解读时，再读取 `references/technical_indicators.md`。
Only read `references/technical_indicators.md` when the user asks for detailed scoring logic, indicator interpretation, or when you need help calibrating a more detailed explanation.
当需要组织最终输出格式、决定默认查询 vs 完整报告、或生成挂单实操建议时，优先读取 `references/output_templates.md`；其中已经定义了默认查询模板、原子模板、完整报告组合规则，以及保守型/平衡型/激进型挂单价格生成规范（默认平衡型）。
When deciding the final output format, choosing between default query vs full report, or generating practical order suggestions, prefer `references/output_templates.md`. It defines the default query template, atomic templates, full-report composition rules, and the conservative / balanced / aggressive order-price generation rules (balanced is the default).
## 重要注意事项
## Important Notes
- 所有分析仅供参考，**不构成投资建议**
- 数据来源以 **腾讯财经** 为主，可能存在延迟、缺口或字段局限
- 港股没有涨跌停限制，波动风险更大
- 每次分析结果末尾**必须**附上风险免责提示
- 技术分析在市场极端情况下可能失效
- 建议用户结合宏观经济环境、行业趋势和公司基本面综合判断
- All analysis is for reference only and is **not investment advice**
- The primary data source is **Tencent Finance**, which may have delays, gaps, or field limitations
- Hong Kong stocks do not have the same daily price-limit structure as A-shares and therefore carry higher intraday volatility risk
- Every final analysis output **must** include a risk disclaimer
- Technical analysis can fail during extreme market conditions
- Encourage the user to combine macro conditions, sector trends, and company fundamentals in final decision-making
- If key execution constraints are missing — such as account data, cash, lot size, or odd-lot support — explicitly say the output is only a **directional recommendation**, not a complete execution-ready trading plan
- Only store user-confirmed durable facts in the database; latest price, market value, unrealized P&L, and position weight should be fetched or calculated at analysis time
## 资源文件
## Resource Files
| 文件 | 用途 |
| File | Purpose |
|------|------|
| `scripts/analyze_stock.py` | 核心分析脚本，获取数据并计算技术指标和基本面评分 |
| `scripts/portfolio_manager.py` | 持仓管理脚本，支持增删改查和批量分析 |
| `scripts/install_deps.sh` | Python 依赖安装脚本 |
| `references/technical_indicators.md` | 技术指标详解和评分标准 |
| `references/output_templates.md` | 分析输出模板总控：默认查询模板、原子模板、完整报告组合规则、挂单价格生成规范 |
| `references/data-source-roadmap.md` | 数据源升级路线图：主源 / fallback / 事件层规划；仅在需要扩展数据源或接入事件信息时读取 |
| `scripts/analyze_stock.py` | Core analysis script for market data retrieval, technical indicators, and valuation scoring |
| `scripts/portfolio_manager.py` | Portfolio/account/watchlist management and batch analysis entry point |
| `scripts/install_deps.sh` | Dependency installation script |
| `references/technical_indicators.md` | Detailed technical indicator and scoring reference |
| `references/output_templates.md` | Output template controller: default query template, atomic templates, full-report rules, and practical order generation rules |
| `references/data-source-roadmap.md` | Data-source roadmap for primary/fallback/event-layer evolution; read only when extending data sources or event coverage |

190
scripts/db.py
View File

@@ -48,15 +48,24 @@ def _table_columns(conn: sqlite3.Connection, table: str) -> list[str]:
return []
def _ensure_column(conn: sqlite3.Connection, table: str, column: str, ddl: str) -> None:
columns = _table_columns(conn, table)
if columns and column not in columns:
conn.execute(f"ALTER TABLE {table} ADD COLUMN {ddl}")
def _migrate_schema(conn: sqlite3.Connection) -> None:
positions_cols = _table_columns(conn, "positions")
if positions_cols and "watchlist_id" not in positions_cols:
conn.execute("DROP TABLE positions")
positions_cols = []
if positions_cols:
_ensure_column(conn, "positions", "account_id", "account_id INTEGER")
def init_db() -> None:
with get_connection() as conn:
_migrate_schema(conn)
conn.executescript(
"""
CREATE TABLE IF NOT EXISTS watchlist (
@@ -83,6 +92,31 @@ def init_db() -> None:
CREATE INDEX IF NOT EXISTS idx_watchlist_market ON watchlist (market, code);
CREATE INDEX IF NOT EXISTS idx_watchlist_is_watched ON watchlist (is_watched, updated_at DESC);
CREATE TABLE IF NOT EXISTS accounts (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL UNIQUE,
market TEXT,
currency TEXT,
cash_balance REAL NOT NULL DEFAULT 0,
available_cash REAL,
note TEXT DEFAULT '',
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_accounts_market_currency
ON accounts (market, currency);
CREATE TABLE IF NOT EXISTS stock_rules (
code TEXT PRIMARY KEY,
lot_size INTEGER,
tick_size REAL,
allows_odd_lot INTEGER NOT NULL DEFAULT 0,
source TEXT DEFAULT 'manual',
updated_at TEXT NOT NULL,
FOREIGN KEY (code) REFERENCES watchlist(code) ON DELETE CASCADE
);
CREATE TABLE IF NOT EXISTS kline_daily (
code TEXT NOT NULL,
trade_date TEXT NOT NULL,
@@ -102,13 +136,15 @@ def init_db() -> None:
CREATE TABLE IF NOT EXISTS positions (
watchlist_id INTEGER PRIMARY KEY,
account_id INTEGER,
buy_price REAL NOT NULL,
shares INTEGER NOT NULL,
buy_date TEXT,
note TEXT DEFAULT '',
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL,
FOREIGN KEY (watchlist_id) REFERENCES watchlist(id) ON DELETE CASCADE
FOREIGN KEY (watchlist_id) REFERENCES watchlist(id) ON DELETE CASCADE,
FOREIGN KEY (account_id) REFERENCES accounts(id) ON DELETE SET NULL
);
CREATE TABLE IF NOT EXISTS analysis_cache (
@@ -142,6 +178,7 @@ def init_db() -> None:
ON aux_cache (code, category, created_at DESC);
"""
)
_migrate_schema(conn)
conn.commit()
@@ -408,6 +445,107 @@ def set_watch_status(code: str, watched: bool) -> dict | None:
return dict(row) if row else None
def list_accounts() -> list[dict]:
init_db()
with get_connection() as conn:
rows = conn.execute(
"""
SELECT id, name, market, currency, cash_balance, available_cash, note, created_at, updated_at
FROM accounts
ORDER BY market IS NULL, market, currency IS NULL, currency, name
"""
).fetchall()
return [dict(row) for row in rows]
def get_account(identifier: int | str) -> dict | None:
init_db()
with get_connection() as conn:
if isinstance(identifier, int) or (isinstance(identifier, str) and identifier.isdigit()):
row = conn.execute("SELECT * FROM accounts WHERE id = ?", (int(identifier),)).fetchone()
else:
row = conn.execute("SELECT * FROM accounts WHERE name = ?", (identifier,)).fetchone()
return dict(row) if row else None
def upsert_account(
*,
name: str,
market: str | None = None,
currency: str | None = None,
cash_balance: float | None = None,
available_cash: float | None = None,
note: str = "",
) -> dict:
init_db()
now = _utc_now_iso()
with get_connection() as conn:
existing = conn.execute("SELECT * FROM accounts WHERE name = ?", (name,)).fetchone()
created_at = existing["created_at"] if existing else now
conn.execute(
"""
INSERT INTO accounts (name, market, currency, cash_balance, available_cash, note, created_at, updated_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
ON CONFLICT(name) DO UPDATE SET
market = COALESCE(excluded.market, accounts.market),
currency = COALESCE(excluded.currency, accounts.currency),
cash_balance = COALESCE(excluded.cash_balance, accounts.cash_balance),
available_cash = COALESCE(excluded.available_cash, accounts.available_cash),
note = CASE WHEN excluded.note = '' THEN accounts.note ELSE excluded.note END,
updated_at = excluded.updated_at
""",
(
name,
market,
currency,
0 if cash_balance is None else cash_balance,
available_cash,
note,
created_at,
now,
),
)
conn.commit()
row = conn.execute("SELECT * FROM accounts WHERE name = ?", (name,)).fetchone()
return dict(row)
def upsert_stock_rule(
*,
code: str,
lot_size: int | None = None,
tick_size: float | None = None,
allows_odd_lot: bool = False,
source: str = "manual",
) -> dict:
init_db()
now = _utc_now_iso()
with get_connection() as conn:
conn.execute(
"""
INSERT INTO stock_rules (code, lot_size, tick_size, allows_odd_lot, source, updated_at)
VALUES (?, ?, ?, ?, ?, ?)
ON CONFLICT(code) DO UPDATE SET
lot_size = COALESCE(excluded.lot_size, stock_rules.lot_size),
tick_size = COALESCE(excluded.tick_size, stock_rules.tick_size),
allows_odd_lot = excluded.allows_odd_lot,
source = excluded.source,
updated_at = excluded.updated_at
""",
(code, lot_size, tick_size, int(allows_odd_lot), source, now),
)
conn.commit()
row = conn.execute("SELECT * FROM stock_rules WHERE code = ?", (code,)).fetchone()
return dict(row)
def get_stock_rule(code: str) -> dict | None:
init_db()
with get_connection() as conn:
row = conn.execute("SELECT * FROM stock_rules WHERE code = ?", (code,)).fetchone()
return dict(row) if row else None
def get_latest_kline_date(code: str, adj_type: str = "qfq") -> str | None:
init_db()
with get_connection() as conn:
@@ -504,6 +642,12 @@ def list_positions() -> list[dict]:
"""
SELECT
p.watchlist_id,
p.account_id,
a.name AS account_name,
a.market AS account_market,
a.currency AS account_currency,
a.cash_balance AS account_cash_balance,
a.available_cash AS account_available_cash,
w.code,
w.market,
w.name,
@@ -513,9 +657,15 @@ def list_positions() -> list[dict]:
p.buy_date,
p.note,
p.created_at AS added_at,
p.updated_at
p.updated_at,
sr.lot_size,
sr.tick_size,
sr.allows_odd_lot,
sr.source AS lot_rule_source
FROM positions p
JOIN watchlist w ON w.id = p.watchlist_id
LEFT JOIN accounts a ON a.id = p.account_id
LEFT JOIN stock_rules sr ON sr.code = w.code
ORDER BY w.code ASC
"""
).fetchall()
@@ -529,6 +679,12 @@ def get_position(code: str) -> dict | None:
"""
SELECT
p.watchlist_id,
p.account_id,
a.name AS account_name,
a.market AS account_market,
a.currency AS account_currency,
a.cash_balance AS account_cash_balance,
a.available_cash AS account_available_cash,
w.code,
w.market,
w.name,
@@ -538,9 +694,15 @@ def get_position(code: str) -> dict | None:
p.buy_date,
p.note,
p.created_at AS added_at,
p.updated_at
p.updated_at,
sr.lot_size,
sr.tick_size,
sr.allows_odd_lot,
sr.source AS lot_rule_source
FROM positions p
JOIN watchlist w ON w.id = p.watchlist_id
LEFT JOIN accounts a ON a.id = p.account_id
LEFT JOIN stock_rules sr ON sr.code = w.code
WHERE w.code = ?
""",
(code,),
@@ -557,6 +719,7 @@ def upsert_position(
shares: int,
buy_date: str | None,
note: str = "",
account_id: int | None = None,
name: str | None = None,
currency: str | None = None,
meta: dict | None = None,
@@ -574,21 +737,23 @@ def upsert_position(
now = _utc_now_iso()
with get_connection() as conn:
existing = conn.execute(
"SELECT created_at FROM positions WHERE watchlist_id = ?", (watch["id"],)
"SELECT created_at, account_id FROM positions WHERE watchlist_id = ?", (watch["id"],)
).fetchone()
created_at = existing["created_at"] if existing else now
account_id_value = account_id if account_id is not None else (existing["account_id"] if existing else None)
conn.execute(
"""
INSERT INTO positions (watchlist_id, buy_price, shares, buy_date, note, created_at, updated_at)
VALUES (?, ?, ?, ?, ?, ?, ?)
INSERT INTO positions (watchlist_id, account_id, buy_price, shares, buy_date, note, created_at, updated_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
ON CONFLICT(watchlist_id) DO UPDATE SET
account_id = excluded.account_id,
buy_price = excluded.buy_price,
shares = excluded.shares,
buy_date = excluded.buy_date,
note = excluded.note,
updated_at = excluded.updated_at
""",
(watch["id"], buy_price, shares, buy_date, note, created_at, now),
(watch["id"], account_id_value, buy_price, shares, buy_date, note, created_at, now),
)
conn.commit()
return get_position(code)
@@ -605,7 +770,13 @@ def remove_position(code: str) -> bool:
return cur.rowcount > 0
def update_position_fields(code: str, price: float | None = None, shares: int | None = None, note: str | None = None) -> dict | None:
def update_position_fields(
code: str,
price: float | None = None,
shares: int | None = None,
note: str | None = None,
account_id: int | None = None,
) -> dict | None:
current = get_position(code)
if not current:
return None
@@ -618,6 +789,7 @@ def update_position_fields(code: str, price: float | None = None, shares: int |
shares=shares if shares is not None else current["shares"],
buy_date=current.get("buy_date"),
note=note if note is not None else current.get("note", ""),
account_id=account_id if account_id is not None else current.get("account_id"),
name=watch.get("name"),
currency=watch.get("currency"),
meta=json.loads(watch["meta_json"]) if watch.get("meta_json") else None,

230
scripts/portfolio_manager.py
View File

@@ -4,10 +4,13 @@
用法:
python3 portfolio_manager.py list
python3 portfolio_manager.py add <代码> --price <买入价> --shares <数量> [--date <日期>] [--note <备注>]
python3 portfolio_manager.py add <代码> --price <买入价> --shares <数量> [--date <日期>] [--note <备注>] [--account <账户名或ID>]
python3 portfolio_manager.py remove <代码>
python3 portfolio_manager.py update <代码> [--price <价格>] [--shares <数量>] [--note <备注>]
python3 portfolio_manager.py update <代码> [--price <价格>] [--shares <数量>] [--note <备注>] [--account <账户名或ID>]
python3 portfolio_manager.py analyze [--output <输出文件>]
python3 portfolio_manager.py account-list
python3 portfolio_manager.py account-upsert <账户名> [--market <市场>] [--currency <币种>] [--cash <总现金>] [--available-cash <可用现金>] [--note <备注>]
python3 portfolio_manager.py rule-set <代码> [--lot-size <每手股数>] [--tick-size <最小价位>] [--odd-lot]
python3 portfolio_manager.py watch-list
python3 portfolio_manager.py watch-add <代码>
python3 portfolio_manager.py watch-remove <代码>
@@ -20,19 +23,24 @@ import json
import argparse
import os
import time
from collections import defaultdict
from datetime import datetime
try:
from db import (
DB_PATH,
get_account,
get_watchlist_item,
init_db,
list_accounts as db_list_accounts,
list_positions as db_list_positions,
list_watchlist as db_list_watchlist,
remove_position as db_remove_position,
set_watch_status,
update_position_fields,
upsert_account,
upsert_position,
upsert_stock_rule,
upsert_watchlist_item,
)
from analyze_stock import fetch_tencent_quote, normalize_stock_code, analyze_stock
@@ -41,14 +49,18 @@ except ImportError:
sys.path.insert(0, script_dir)
from db import (
DB_PATH,
get_account,
get_watchlist_item,
init_db,
list_accounts as db_list_accounts,
list_positions as db_list_positions,
list_watchlist as db_list_watchlist,
remove_position as db_remove_position,
set_watch_status,
update_position_fields,
upsert_account,
upsert_position,
upsert_stock_rule,
upsert_watchlist_item,
)
from analyze_stock import fetch_tencent_quote, normalize_stock_code, analyze_stock
@@ -58,6 +70,15 @@ def normalize_code(code: str) -> str:
return normalize_stock_code(code)["code"]
def resolve_account(account_ref: str | None):
if not account_ref:
return None
account = get_account(account_ref)
if not account:
raise ValueError(f"账户不存在: {account_ref}")
return account
def ensure_watch_item(code: str, watched: bool = False) -> dict:
stock = normalize_stock_code(code)
quote = fetch_tencent_quote(stock["code"])
@@ -81,6 +102,65 @@ def ensure_watch_item(code: str, watched: bool = False) -> dict:
)
def derive_execution_constraints(position: dict, current_price: float | None = None) -> dict:
shares = int(position.get("shares") or 0)
lot_size = position.get("lot_size")
allows_odd_lot = bool(position.get("allows_odd_lot") or False)
if lot_size is None or lot_size <= 0:
whole_lots = None
remainder = None
can_partial_sell = None
sellable_min_unit = 1 if allows_odd_lot else None
else:
whole_lots = shares // lot_size
remainder = shares % lot_size
can_partial_sell = allows_odd_lot or whole_lots >= 2 or remainder > 0
sellable_min_unit = 1 if allows_odd_lot else lot_size
estimated_cash_if_sell_all = round(shares * current_price, 2) if current_price is not None else None
return {
"lot_size": lot_size,
"allows_odd_lot": allows_odd_lot,
"sellable_min_unit": sellable_min_unit,
"whole_lots": whole_lots,
"odd_lot_remainder": remainder,
"can_partial_sell": can_partial_sell,
"estimated_cash_if_sell_all": estimated_cash_if_sell_all,
}
def derive_position_snapshot(position: dict, analysis: dict) -> dict:
current_price = analysis.get("current_price")
buy_price = position.get("buy_price")
shares = int(position.get("shares") or 0)
cost = round((buy_price or 0) * shares, 2)
market_value = round((current_price or 0) * shares, 2) if current_price is not None else None
pnl = round((current_price - buy_price) * shares, 2) if current_price is not None and buy_price is not None else None
pnl_pct = round((current_price - buy_price) / buy_price * 100, 2) if current_price is not None and buy_price not in (None, 0) else None
execution = derive_execution_constraints(position, current_price)
return {
"buy_price": buy_price,
"shares": shares,
"buy_date": position.get("buy_date"),
"cost": cost,
"market_value": market_value,
"pnl": pnl,
"pnl_pct": pnl_pct,
"note": position.get("note", ""),
"currency": position.get("currency"),
"market": position.get("market"),
"account": {
"id": position.get("account_id"),
"name": position.get("account_name"),
"market": position.get("account_market"),
"currency": position.get("account_currency"),
"cash_balance": position.get("account_cash_balance"),
"available_cash": position.get("account_available_cash"),
},
"execution_constraints": execution,
}
# ─────────────────────────────────────────────
# 持仓管理
# ─────────────────────────────────────────────
@@ -99,7 +179,7 @@ def list_positions():
}, ensure_ascii=False, indent=2))
def add_position(code: str, price: float, shares: int, date: str = None, note: str = ""):
def add_position(code: str, price: float, shares: int, date: str = None, note: str = "", account_ref: str = None):
init_db()
normalized = normalize_stock_code(code)
existing = next((p for p in db_list_positions() if p["code"] == normalized["code"]), None)
@@ -107,6 +187,7 @@ def add_position(code: str, price: float, shares: int, date: str = None, note: s
print(json.dumps({"error": f"{normalized['code']} 已在持仓中，请使用 update 命令更新"}, ensure_ascii=False))
return
account = resolve_account(account_ref)
watch = ensure_watch_item(normalized["code"], watched=True)
position = upsert_position(
code=normalized["code"],
@@ -116,6 +197,7 @@ def add_position(code: str, price: float, shares: int, date: str = None, note: s
shares=shares,
buy_date=date or datetime.now().strftime("%Y-%m-%d"),
note=note,
account_id=account.get("id") if account else None,
name=watch.get("name"),
currency=watch.get("currency"),
meta=json.loads(watch["meta_json"]) if watch.get("meta_json") else None,
@@ -133,16 +215,53 @@ def remove_position(code: str):
print(json.dumps({"message": f"已移除 {normalized_code}"}, ensure_ascii=False, indent=2))
def update_position(code: str, price: float = None, shares: int = None, note: str = None):
def update_position(code: str, price: float = None, shares: int = None, note: str = None, account_ref: str = None):
init_db()
normalized_code = normalize_code(code)
position = update_position_fields(normalized_code, price=price, shares=shares, note=note)
account = resolve_account(account_ref) if account_ref else None
position = update_position_fields(normalized_code, price=price, shares=shares, note=note, account_id=account.get("id") if account else None)
if not position:
print(json.dumps({"error": f"{normalized_code} 不在持仓中"}, ensure_ascii=False))
return
print(json.dumps({"message": f"已更新 {normalized_code}", "position": position}, ensure_ascii=False, indent=2))
# ─────────────────────────────────────────────
# 账户与交易规则管理
# ─────────────────────────────────────────────
def list_accounts():
init_db()
accounts = db_list_accounts()
print(json.dumps({
"total_accounts": len(accounts),
"accounts": accounts,
"portfolio_db": str(DB_PATH),
"updated_at": datetime.now().isoformat(),
}, ensure_ascii=False, indent=2))
def save_account(name: str, market: str = None, currency: str = None, cash: float = None, available_cash: float = None, note: str = ""):
init_db()
account = upsert_account(
name=name,
market=market,
currency=currency,
cash_balance=cash,
available_cash=available_cash,
note=note,
)
print(json.dumps({"message": f"已保存账户 {name}", "account": account}, ensure_ascii=False, indent=2))
def set_rule(code: str, lot_size: int = None, tick_size: float = None, odd_lot: bool = False):
init_db()
normalized_code = normalize_code(code)
ensure_watch_item(normalized_code, watched=False)
rule = upsert_stock_rule(code=normalized_code, lot_size=lot_size, tick_size=tick_size, allows_odd_lot=odd_lot)
print(json.dumps({"message": f"已设置 {normalized_code} 的交易规则", "rule": rule}, ensure_ascii=False, indent=2))
# ─────────────────────────────────────────────
# 关注池管理
# ─────────────────────────────────────────────
@@ -186,40 +305,44 @@ def analyze_portfolio(output_file: str = None):
return
results = []
account_totals = defaultdict(lambda: {"cost": 0.0, "market_value": 0.0})
market_currency_totals = defaultdict(lambda: {"cost": 0.0, "market_value": 0.0})
for i, pos in enumerate(positions):
code = pos["code"]
print(f"正在分析 {code} ({i+1}/{len(positions)})...", file=sys.stderr)
analysis = analyze_stock(code)
if analysis.get("current_price") and pos.get("buy_price"):
current = analysis["current_price"]
buy = pos["buy_price"]
shares = pos.get("shares", 0)
pnl = (current - buy) * shares
pnl_pct = (current - buy) / buy * 100
analysis["portfolio_info"] = {
"buy_price": buy,
"shares": shares,
"buy_date": pos.get("buy_date"),
"cost": round(buy * shares, 2),
"market_value": round(current * shares, 2),
"pnl": round(pnl, 2),
"pnl_pct": round(pnl_pct, 2),
"note": pos.get("note", ""),
"currency": pos.get("currency"),
"market": pos.get("market"),
}
analysis["portfolio_info"] = derive_position_snapshot(pos, analysis)
results.append(analysis)
snapshot = analysis["portfolio_info"]
market_value = snapshot.get("market_value") or 0.0
cost = snapshot.get("cost") or 0.0
account_name = snapshot.get("account", {}).get("name") or "未分配账户"
account_totals[account_name]["cost"] += cost
account_totals[account_name]["market_value"] += market_value
mc_key = f"{snapshot.get('market') or 'UNKNOWN'}:{snapshot.get('currency') or 'UNKNOWN'}"
market_currency_totals[mc_key]["cost"] += cost
market_currency_totals[mc_key]["market_value"] += market_value
if i < len(positions) - 1 and not analysis.get("_from_cache"):
time.sleep(2)
total_cost = sum(r.get("portfolio_info", {}).get("cost", 0) for r in results)
total_value = sum(r.get("portfolio_info", {}).get("market_value", 0) for r in results)
total_cost = sum(r.get("portfolio_info", {}).get("cost", 0) or 0 for r in results)
total_value = sum(r.get("portfolio_info", {}).get("market_value", 0) or 0 for r in results)
total_pnl = total_value - total_cost
for analysis in results:
snapshot = analysis.get("portfolio_info", {})
market_value = snapshot.get("market_value") or 0.0
account = snapshot.get("account") or {}
account_name = account.get("name") or "未分配账户"
account_total_value = account_totals[account_name]["market_value"]
snapshot["position_weight_of_portfolio_pct"] = round(market_value / total_value * 100, 2) if total_value > 0 else None
snapshot["position_weight_of_account_pct"] = round(market_value / account_total_value * 100, 2) if account_total_value > 0 else None
summary = {
"analysis_time": datetime.now().isoformat(),
"total_positions": len(results),
@@ -227,6 +350,24 @@ def analyze_portfolio(output_file: str = None):
"total_market_value": round(total_value, 2),
"total_pnl": round(total_pnl, 2),
"total_pnl_pct": round(total_pnl / total_cost * 100, 2) if total_cost > 0 else 0,
"accounts": [
{
"name": name,
"total_cost": round(v["cost"], 2),
"total_market_value": round(v["market_value"], 2),
"total_pnl": round(v["market_value"] - v["cost"], 2),
}
for name, v in sorted(account_totals.items())
],
"market_currency_breakdown": [
{
"market_currency": key,
"total_cost": round(v["cost"], 2),
"total_market_value": round(v["market_value"], 2),
"total_pnl": round(v["market_value"] - v["cost"], 2),
}
for key, v in sorted(market_currency_totals.items())
],
"positions": results,
}
@@ -245,6 +386,7 @@ def main():
subparsers = parser.add_subparsers(dest="command", help="子命令")
subparsers.add_parser("list", help="列出所有持仓")
subparsers.add_parser("account-list", help="列出账户")
add_parser = subparsers.add_parser("add", help="添加持仓")
add_parser.add_argument("code", help="股票代码")
@@ -252,6 +394,7 @@ def main():
add_parser.add_argument("--shares", type=int, required=True, help="持有数量")
add_parser.add_argument("--date", help="买入日期 (YYYY-MM-DD)")
add_parser.add_argument("--note", default="", help="备注")
add_parser.add_argument("--account", help="账户名或账户ID")
rm_parser = subparsers.add_parser("remove", help="移除持仓")
rm_parser.add_argument("code", help="股票代码")
@@ -261,11 +404,26 @@ def main():
up_parser.add_argument("--price", type=float, help="买入价格")
up_parser.add_argument("--shares", type=int, help="持有数量")
up_parser.add_argument("--note", help="备注")
up_parser.add_argument("--account", help="账户名或账户ID")
analyze_parser = subparsers.add_parser("analyze", help="批量分析持仓")
analyze_parser.add_argument("--output", help="输出JSON文件")
watch_list_parser = subparsers.add_parser("watch-list", help="列出关注池")
account_parser = subparsers.add_parser("account-upsert", help="新增或更新账户")
account_parser.add_argument("name", help="账户名")
account_parser.add_argument("--market", help="市场，例如 HK/CN/US")
account_parser.add_argument("--currency", help="币种，例如 HKD/CNY/USD")
account_parser.add_argument("--cash", type=float, help="账户总现金")
account_parser.add_argument("--available-cash", type=float, help="账户可用现金")
account_parser.add_argument("--note", default="", help="备注")
rule_parser = subparsers.add_parser("rule-set", help="设置股票交易规则")
rule_parser.add_argument("code", help="股票代码")
rule_parser.add_argument("--lot-size", type=int, help="一手股数")
rule_parser.add_argument("--tick-size", type=float, help="最小价位变动")
rule_parser.add_argument("--odd-lot", action="store_true", help="允许碎股")
subparsers.add_parser("watch-list", help="列出关注池")
watch_add_parser = subparsers.add_parser("watch-add", help="添加关注股票")
watch_add_parser.add_argument("code", help="股票代码")
watch_remove_parser = subparsers.add_parser("watch-remove", help="取消关注股票")
@@ -273,16 +431,23 @@ def main():
args = parser.parse_args()
try:
if args.command == "list":
list_positions()
elif args.command == "add":
add_position(args.code, args.price, args.shares, args.date, args.note)
add_position(args.code, args.price, args.shares, args.date, args.note, args.account)
elif args.command == "remove":
remove_position(args.code)
elif args.command == "update":
update_position(args.code, args.price, args.shares, args.note)
update_position(args.code, args.price, args.shares, args.note, args.account)
elif args.command == "analyze":
analyze_portfolio(args.output)
elif args.command == "account-list":
list_accounts()
elif args.command == "account-upsert":
save_account(args.name, args.market, args.currency, args.cash, args.available_cash, args.note)
elif args.command == "rule-set":
set_rule(args.code, args.lot_size, args.tick_size, args.odd_lot)
elif args.command == "watch-list":
list_watchlist()
elif args.command == "watch-add":
@@ -291,6 +456,9 @@ def main():
remove_watch(args.code)
else:
parser.print_help()
except ValueError as e:
print(json.dumps({"error": str(e)}, ensure_ascii=False, indent=2))
sys.exit(1)
if __name__ == "__main__":