Aifp

🚀 AIFP：AI 函数式过程编程

AIFP 是一种与语言无关的编程范式，专为 AI 生成和维护的代码库而设计。它结合了纯函数式编程原则、过程式执行模式、数据库驱动的项目管理以及基于指令的 AI 指导，旨在优化 AI 与人类的协作。

🚀 快速开始

前提条件

• Python 3.11+（代码中使用了类型提示语法，因此需要此版本）

安装

方法 1：pip 安装（推荐）

pip install aifp

此方法将安装 MCP 服务器，并使 aifp 命令可用。AIFP 仅需要一个外部依赖（watchdog 用于文件系统监控），JSON-RPC 服务器本身是纯 Python 标准库。

方法 2：手动安装（从 GitHub 下载）

1. 下载 仓库（通过 zip 下载或 git clone）
2. 定位 src/aifp/ 文件夹，这是完整的 MCP 服务器包
3. 复制 aifp/ 文件夹到你存放 MCP 服务器的位置：

# 示例：复制到你的 MCP 服务器目录
cp -r src/aifp/ ~/mcp-servers/aifp/

唯一的运行时依赖（watchdog）会自动安装。aifp/ 文件夹包含服务器所需的所有内容：辅助函数、指令、数据库模式和预填充的 aifp_core.db。

将系统提示添加到你的 AI 客户端

此步骤是必需的。系统提示会告诉 AI 主动使用 AIFP 工具。如果没有它，MCP 服务器只是一组被动工具，不会被调用。

在终端中打印系统提示，然后将其复制粘贴到你的 AI 客户端：

python3 -m aifp --system-prompt

系统提示随包一起提供，无需单独的文件或下载。此方法适用于所有安装方式（pip、虚拟环境、手动安装）。

粘贴位置（取决于你的 AI 客户端）：

配置你的 AI 客户端

在你的 AI 客户端配置中注册 AIFP MCP 服务器。服务器使用 标准输入输出传输，它从标准输入读取 JSON-RPC 消息，并将响应写入标准输出。

Claude 桌面版

编辑 claude_desktop_config.json：

{
  "mcpServers": {
    "aifp": {
      "command": "python3",
      "args": ["-m", "aifp"],
      "env": {}
    }
  }
}

如果你使用 方法 2（手动安装），将 aifp/ 文件夹的父目录添加到 PYTHONPATH，以便 Python 可以找到它：

{
  "mcpServers": {
    "aifp": {
      "command": "python3",
      "args": ["-m", "aifp"],
      "env": {
        "PYTHONPATH": "/path/to/parent-of-aifp-folder"
      }
    }
  }
}

例如，如果你将 aifp/ 复制到 ~/mcp-servers/aifp/，则将 PYTHONPATH 设置为 ~/mcp-servers。

如果你安装到 虚拟环境 中，使用虚拟环境的 Python 完整路径，以便 Claude 桌面版使用正确的解释器：

{
  "mcpServers": {
    "aifp": {
      "command": "/path/to/venv/bin/python3",
      "args": ["-m", "aifp"],
      "env": {}
    }
  }
}

Claude 代码版

使用 claude mcp add 注册服务器。在你希望 AIFP 管理的项目文件夹内运行此命令。

首先选择作用域。AIFP 强制执行严格的函数式编程，并主动拒绝面向对象编程的代码库。如果你处理其他使用面向对象编程或不需要 AIFP 的项目，请避免使用 --scope user，因为它会在你打开的每个项目中启用服务器。

pip 安装（系统级）：

claude mcp add --transport stdio --scope project aifp -- python3 -m aifp

pip 安装（虚拟环境） — 使用虚拟环境的 Python 路径：

claude mcp add --transport stdio --scope project aifp -- /path/to/venv/bin/python3 -m aifp

单纯的 python3 会解析为系统 Python，可能没有安装该包。使用虚拟环境解释器的完整路径，以便 MCP 服务器子进程找到安装的包。

手动安装或从源代码运行 — 将 PYTHONPATH 设置为 aifp/ 文件夹的父目录：

claude mcp add --transport stdio --scope project --env PYTHONPATH=/path/to/parent-of-aifp aifp -- python3 -m aifp

快速参考：

注意：所有标志（--transport、--scope、--env）必须在服务器名称之前。-- 用于分隔名称和命令。在 Claude 代码中使用 /mcp 验证服务器是否已连接。

Claude 代码版：预批准所有 AIFP 工具（可选）

Claude 代码在首次调用每个新 MCP 工具时会提示你批准。由于有 207 个工具，这意味着会有 207 个批准提示。为了跳过此步骤，将预构建的权限文件复制到项目的 .claude/ 文件夹中：

# 如果项目根目录中没有 .claude/ 文件夹，则创建它
mkdir -p /path/to/your/project/.claude

# 复制权限文件
cp documentation/settings.local.json /path/to/your/project/.claude/

这会在项目的 .claude/ 文件夹中放置一个 settings.local.json 文件，该文件会预允许所有 AIFP 工具。Claude 代码会自动读取该文件，无需批准提示。

注意：该文件还包括 enableAllProjectMcpServers 和 enabledMcpjsonServers 设置，因此如果你在项目中有 .mcp.json 文件，AIFP 服务器会自动启动。

其他 MCP 客户端

服务器使用 标准输入输出传输。将你的客户端指向 python3 -m aifp（或虚拟环境的 Python 完整路径）。对于手动安装，确保 PYTHONPATH 包含 aifp/ 文件夹的父目录。无需 API 密钥或身份验证。

工作原理

服务器使用模型上下文协议通过标准输入输出进行通信。它相对于自身安装位置解析 aifp_core.db（指令数据库），无需环境变量。

连接后，AI 在每次交互时调用 aifp_run()（由系统提示引导）。项目状态存储在工作目录的 .aifp-project/ 中，在初始化项目时会自动创建。

项目初始化

告诉你的 AI 助手：

"为我的项目初始化 AIFP"

AI 调用 aifp_init，在项目根目录创建一个 .aifp-project/ 文件夹，其中包含用于项目状态跟踪、用户偏好的数据库和一个项目蓝图文档。你无需与这些文件交互，MCP 服务器会自动管理它们。

✨ 主要特性

• 全面的 MCP 工具：为 4 个 SQLite 数据库提供完整的 CRUD 操作，涵盖项目管理、FP 指令、用户偏好和自定义自动化指令。
• 纯函数式强制：AI 默认编写符合 FP 的代码（纯函数、不可变性、无 OOP）。
• 数据库驱动的持久内存：项目状态在会话间保持，无上下文丢失。
• 基于指令的工作流：采用确定性的主干 → 分支 → 回退执行模式。
• 有限的完成路径：项目有定义好的阶段、里程碑和任务，工作朝着完成收敛。
• 两种用例：常规软件开发（用例 1）或自定义指令自动化（用例 2）。
• 用户偏好学习：AI 通过每个指令的键值覆盖适应编码风格。
• Git 集成：基于 FP 的分支管理和冲突解决。
• 最小依赖：一个运行时包（watchdog），自定义 JSON-RPC 服务器仅使用标准库。
• 成本意识设计：所有跟踪/分析功能默认禁用。

📦 安装指南

前提条件

• Python 3.11+（代码中使用了类型提示语法，因此需要此版本）

安装

方法 1：pip 安装（推荐）

pip install aifp

此方法将安装 MCP 服务器，并使 aifp 命令可用。AIFP 仅需要一个外部依赖（watchdog 用于文件系统监控），JSON-RPC 服务器本身是纯 Python 标准库。

方法 2：手动安装（从 GitHub 下载）

1. 下载 仓库（通过 zip 下载或 git clone）
2. 定位 src/aifp/ 文件夹，这是完整的 MCP 服务器包
3. 复制 aifp/ 文件夹到你存放 MCP 服务器的位置：

# 示例：复制到你的 MCP 服务器目录
cp -r src/aifp/ ~/mcp-servers/aifp/

唯一的运行时依赖（watchdog）会自动安装。aifp/ 文件夹包含服务器所需的所有内容：辅助函数、指令、数据库模式和预填充的 aifp_core.db。

💻 使用示例

示例 1：项目初始化

用户提示："帮我构建一个计算器"

工具调用：

1. aifp_run(is_new_session=true)
   → 返回：会话包（指令名称、设置、项目状态、支持性上下文）
   → 状态显示：.aifp-project/ 缺失 — 未初始化

2. aifp_init(project_root="/home/user/calculator")
   → 返回：{ success: true, message: "项目已初始化" }

发生的事情：

• AI 检测到项目不存在，自动调用 aifp_init 辅助函数
• 创建 .aifp-project/ 目录，包含 project.db、user_preferences.db 和 ProjectBlueprint.md
• 注册项目元数据（名称、根路径、基础设施）
• 插入默认用户设置和备份配置
• AI 进入阶段 2：与用户讨论项目形态（基础设施、目的、目标）
• 路由到 project_discovery 进行协作规划（主题、流程、完成路径、里程碑）

示例 2：编写符合 FP 的代码

用户提示："编写一个 multiply_matrices 函数"

工具调用：

1. aifp_run(is_new_session=false)
   → 返回：轻量级指导

2. reserve_file(project_root="/home/user/calculator", name="matrix_operations", ...)
   → 返回：{ success: true, data: { id: 42 } }

3. reserve_function(project_root="/home/user/calculator", name="multiply_matrices", file_id=42, ...)
   → 返回：{ success: true, data: { id: 99 } }

   (AI 将符合 FP 的代码写入 src/matrix_operations_id_42.py)

4. finalize_file(project_root="/home/user/calculator", file_id=42, path="src/matrix_operations_id_42.py", ...)
   → 返回：{ success: true }

5. finalize_function(project_root="/home/user/calculator", function_id=99, line_start=5, line_end=25, ...)
   → 返回：{ success: true }

发生的事情：

• 在写入之前，文件和函数在 project.db 中预留（ID 嵌入名称中）
• AI 按照 FP 基线编写纯函数代码（无 OOP、无突变、显式参数）
• 文件和函数使用行号和元数据完成
• 项目数据库现在跟踪代码结构，以便在未来会话中即时检索

示例 3：恢复工作 / 检查状态

用户提示："我们进展到哪里了？" 或 "继续工作"

工具调用：

1. aifp_run(is_new_session=false)
   → 返回：指导 + 常见起点

   (AI 从缓存上下文回答 — 除非上下文过期，否则无需额外的数据库调用)

2. aifp_status(project_root="/home/user/calculator", type="detailed")
   → 返回：项目元数据、活动里程碑、当前任务、最近的笔记、警告

发生的事情：

• AI 展示当前里程碑、活动任务和下一步步骤
• 如果 project_continue_on_start=true，AI 自动开始下一个任务
• 无需重新解析源代码 — 所有内容都在 project.db 中索引

📚 详细文档

指令参考

所有指令文档随包一起提供，位于 src/aifp/reference/directives/，共 129 个 MD 文件，涵盖每个指令。每个文件包括：目的、应用时机、完整工作流（主干 → 分支）、合规/不合规示例、边缘情况、相关指令、使用的辅助函数和数据库操作。

数据库模式

模式 SQL 文件位于包中的 src/aifp/database/schemas/：

• aifp_core.sql — 全局只读数据库（指令、辅助函数、流程）
• project.sql — 每个项目的可变数据库（文件、函数、任务、里程碑）
• user_preferences.sql — 每个项目的用户自定义数据库
• user_directives.sql — 每个项目的自动化指令（仅用例 2）

🔧 技术细节

核心原则

1. 函数式 - 过程式混合

# ✅ 符合 AIFP
def calculate_total(items: List[Item]) -> float:
    """纯函数：确定性，无副作用"""
    return reduce(lambda acc, item: acc + item.price, items, 0.0)

# ❌ 不符合 AIFP
class Calculator:
    def __init__(self):
        self.total = 0  # 隐藏状态

    def add_item(self, item):
        self.total += item.price  # 突变

2. 数据库索引逻辑

每个函数、文件和依赖项都在 SQLite 中跟踪。AI 通过辅助工具访问这些数据，而不是原始 SQL：

AI 调用：get_functions_by_file(project_root, file_id)
→ 返回：该文件中的所有函数，包括名称、用途、行号、依赖项

无需重新解析源代码。跨会话即时检索上下文。

3. AI 可读代码

• 扁平结构：无深层继承层次结构
• 显式依赖：所有参数显式传递
• 纯函数：相同输入 → 相同输出
• 元数据注释：机器可读的函数头

4. 有限完成路径

项目：MatrixCalculator
├── 完成路径（3 个阶段）
│   ├── 1. 设置（已完成）
│   ├── 2. 核心开发（进行中）
│   │   ├── 里程碑：矩阵运算
│   │   │   ├── 任务：实现乘法
│   │   │   ├── 任务：实现转置
│   │   │   └── 任务：添加验证
│   │   └── 里程碑：向量运算
│   └── 3. 最终确定（待完成）

5. 与语言无关

AIFP 适用于 Python、JavaScript、TypeScript、Rust、Go 等。FP 指令适应特定语言的语法，同时保持通用标准。

架构概述

┌─────────────────────────────────────────────────────┐
│            AI 助手（Claude、GPT - 4 等）            │
│  - 接收自然语言命令                                │
│  - 遵循指令（FP 基线 + 项目管理）                 │
│  - 调用 MCP 工具读写数据库                        │
│  - 生成符合 FP 的代码                              │
└────────────────────┬────────────────────────────────┘
                     │ MCP 协议（通过标准输入输出的 JSON - RPC）
┌────────────────────▼────────────────────────────────┐
│                 MCP 服务器                         │
│  - 通过 JSON - RPC 公开辅助工具                    │
│  - 管理四个数据库连接                             │
│  - 为所有数据库提供 CRUD 辅助函数                 │
│  - 无业务逻辑 — AI 做出所有决策                   │
└───┬────────────────────┬─────────────────────────┬──┘
    │                    │                         │
┌───▼──────────────┐ ┌───▼────────────────┐ ┌─────▼─────────────────┐ ┌──────▼────────────────┐
│  aifp_core.db    │ │  project.db        │ │  user_preferences.db  │ │  user_directives.db   │
│  (全局，只读)    │ │  (每个项目，可变)  │ │  (每个项目，可变)    │ │  (每个项目，可选)     │
│                  │ │                    │ │                       │ │                       │
│ - FP 指令        │ │ - 项目元数据       │ │ - 指令偏好           │ │ - 用户指令           │
│ - 项目管理       │ │ - 文件和函数       │ │ - 用户设置           │ │ - 执行统计           │
│ - 用户偏好       │ │ - 任务层次结构     │ │ - AI 学习日志        │ │ - 依赖项             │
│ - 用户系统       │ │ - 主题和流程       │ │ - 跟踪功能           │ │ - 生成的代码引用     │
│ - 辅助定义       │ │ - 完成路径         │ │ (所有可选)           │ │ - 源文件跟踪         │
│ - 指令流         │ │ - 运行时笔记       │ │                       │ │ (文件中的日志)       │
└──────────────────┘ └────────────────────┘ └───────────────────────┘ └───────────────────────┘

数据库架构

aifp_core.db（全局，只读）

位置：在 MCP 服务器安装目录内（用户定义的位置，在 AI 客户端中配置）

目的：包含所有 AIFP 标准、指令和辅助定义的不可变知识库。

关键表：

• directives：所有 FP、项目和用户偏好指令（工作流、关键字、阈值）
• helper_functions：数据库、文件、Git 和 FP 实用程序，组织在多个注册表文件中
• directive_helpers：多对多关联表，将指令映射到其辅助函数，并包含执行元数据
• directives_interactions：跨指令关系和依赖项
• categories：指令分组（纯度、不可变性、任务管理等）
• tools：MCP 工具定义

辅助 - 指令关系（v1.4 新增）：

• 一个指令可以使用多个辅助函数，一个辅助函数可以为多个指令服务
• 关联表存储：执行上下文、顺序、参数映射
• 实现灵活的辅助函数重用和清晰的执行流程
• 在 aifp_core.db 的 directive_helpers 关联表中定义

辅助函数分类：

• 工具：所有辅助函数都作为 MCP 工具公开（AI 通过 MCP 直接调用）
• 子辅助函数 (is_sub_helper = TRUE)：仅由其他辅助函数调用的内部实用程序（不向 AI 公开）

辅助函数注册表（开发阶段）：

• 开发期间，辅助函数定义保存在 docs/helpers/json/*.json 中
• 开发人员修改 JSON 文件，完成后导入数据库
• 每个辅助函数包括 used_by_directives 字段用于关系映射
• 数据库导入脚本在发布前从 JSON 文件填充 aifp_core.db
• 生产环境：用户查询 aifp_core.db（预填充），而不是 JSON 文件
• JSON 文件是仅用于开发的临时区域，不会随包一起发布

只读原则：此数据库在部署后进行版本控制且不可变。AI 从中读取但从不修改。

project.db（每个项目，可变）

位置：<project - root>/.aifp - project/project.db

目的：单个 AIFP 项目的持久状态。跟踪代码结构、任务和运行时笔记。

关键表：

• project：高级元数据（名称、目的、目标、状态、用户指令状态、最后已知的 Git 哈希）
• files、functions、interactions：代码结构跟踪
• themes、flows：组织分组
• completion_path、milestones、tasks、subtasks、sidequests：分层路线图
• notes：带有可选指令上下文的运行时日志（源、严重性、指令名称）
• types：代数数据类型（ADTs）
• infrastructure：项目设置（语言、包、测试）
• work_branches：Git 协作元数据（用户、目的、合并策略）
• merge_history：基于 FP 的合并冲突解决审计跟踪

用户指令集成：project.user_directives_status 字段跟踪用户指令是否初始化（NULL/进行中/活动/禁用），允许 aifp_run 和 aifp_status 指令在活动时包含用户指令上下文。

增强的笔记：notes 表现在包括 source（用户/AI/指令）、directive_name（可选上下文）和 severity（信息/警告/错误），以提高可追溯性。

user_preferences.db（每个项目，可变）

位置：<project - root>/.aifp - project/user_preferences.db

目的：用户特定的 AI 行为自定义和可选跟踪功能。

关键表：

• directive_preferences：每个指令的行为覆盖（原子键值结构）
• user_settings：项目范围的 AI 行为设置
• tracking_settings：可选跟踪的功能标志（默认全部禁用）
• ai_interaction_log：用户更正和学习数据（可选）
• fp_flow_tracking：FP 合规历史（可选）
• issue_reports：上下文相关的错误报告（可选）

成本管理原则：所有跟踪功能默认禁用，以最小化 API 令牌使用。项目工作应具有成本效益；调试和分析是可选的。

用户自定义示例：

-- 用户说："始终添加文档字符串"
INSERT INTO directive_preferences (directive_name, preference_key, preference_value)
VALUES ('project_file_write', 'always_add_docstrings', 'true');

-- 下次文件写入将自动包含文档字符串

user_directives.db（每个项目，可选）

位置：<project - root>/.aifp - project/user_directives.db

目的：存储用户定义的特定领域指令，用于自动化（家庭自动化、云基础设施等）。当此数据库存在时，AIFP 项目专门用于构建和管理从这些指令生成的自动化代码库。

此数据库仅存在于 用例 2：自定义指令自动化 项目中。在常规软件开发项目中，不会创建此数据库。

关键表：

• user_directives：指令定义（触发器、操作、状态、验证配置）
• directive_executions：执行统计（仅摘要，详细日志在文件中）
• directive_dependencies：所需的包、API、环境变量
• directive_implementations：将指令链接到生成的代码文件
• helper_functions：AI 生成的辅助函数（特定项目的实现实用程序）
• directive_helpers：多对多关联表，将用户指令映射到其辅助函数
• source_files：跟踪用户指令源文件（YAML/JSON/TXT）
• logging_config：基于文件的日志配置

辅助函数（v1.0 新增）：

• AI 为用户指令生成特定项目的辅助函数
• 跟踪实现状态：未实现 → 生成 → 测试 → 批准
• 对所有生成的代码强制执行 FP 合规性（纯函数）
• 与 aifp_core.db 采用相同的多对多关系模式

基于文件的日志记录原则：数据库仅存储状态和统计信息。详细的执行日志（30 天保留）和错误日志（90 天保留）存储在 .aifp - project/logs/ 的轮转文件中。

目录结构比较：

# 用例 1：常规软件开发
my - web - app/
├── src/                    # 你的应用程序代码
├── tests/                  # 你的测试
└── .aifp - project/        # AIFP 跟踪你的应用程序
    ├── project.db
    └── user_preferences.db

# 用例 2：自定义指令自动化
home - automation/
├── directives/             # ← 用户在此编写指令文件
│   ├── lights.yaml
│   └── security.yaml
├── src/                    # ← AIFP 生成此代码
│   ├── lights_controller.py
│   └── security_monitor.py
├── tests/                  # ← AIFP 生成测试
└── .aifp - project/        # ← 仅由 AI 管理，用户从不触碰
    ├── project.db          # 跟踪生成的 src/ 代码
    ├── user_preferences.db
    ├── user_directives.db  # 引用 ../directives/ 文件
    └── logs/               # 30/90 天执行日志

示例工作流（自动化项目）：

1. 用户在项目中创建 directives/lights.yaml
2. 用户告诉 AI："解析我在 directives/lights.yaml 的指令文件"
3. AI 通过交互式问答解析并验证
4. AI 在 src/ 中生成符合 FP 的实现代码
5. AI 在 project.db 中跟踪生成的代码（文件、函数、任务）
6. 指令通过后台服务实时执行
7. 执行日志记录到 .aifp - project/logs/，统计信息记录到数据库

注意：用户指令文件保留在用户项目中。.aifp - project/ 是 AI 管理的元数据。

工作原理

1. AIFP MCP 网关模式

aifp_run 命令作为 网关和提醒，而不是执行器。它告诉 AI 应该应用 AIFP 指令。

每次 aifp_run 调用返回：

{
  "success": true,
  "message": "AIFP MCP 可用",
  "guidance": {
    "directive_access": "从会话包中缓存指令名称。需要时按名称查询特定指令。",
    "when_to_use": "在编码或需要项目管理操作/响应时使用 AIFP 指令。",
    "assumption": "除非用户明确拒绝，否则始终假设 AIFP 适用。"
  }
}

MCP 服务器为所有数据库操作公开 CRUD 辅助函数 — 跟踪文件、函数、任务、项目状态、用户偏好和（对于用例 2）自动化指令。AI 在运行时从数据库中发现可用的辅助函数。

AI 决策流程：

1. 用户在请求前加上 aifp run（或 AI 假设）
2. AI 调用 aifp_run 工具 → 接收指导
3. AI 评估：这是编码还是项目管理？
4. 如果是：检查指令是否在内存中
   • 没有指令？ → 调用 get_all_directives()
   • 有指令？ → 应用适当的指令
5. 如果不是：不使用指令进行响应

2. 命令流程示例

用户："帮我构建一个计算器"

AI 处理：

1. 调用 aifp_run(is_new_session=true) → 接收会话包（指令名称、项目状态、设置、支持性上下文）
2. 从包中检查项目状态：.aifp - project/ 缺失 → 项目未初始化
3. 调用 aifp_init 辅助函数（阶段 1：机械设置）
   • 以编程方式创建 .aifp - project/ 目录、数据库、蓝图模板
4. 进入阶段 2（智能填充）：检测语言/工具，与用户讨论项目
5. 路由到 project_discovery：与用户协作确定蓝图、主题、流程、完成路径、里程碑
6. 发现完成 → 路由到 aifp_status → project_progression → 创建第一个任务
7. 开始工作

3. 自我评估框架

在行动之前，AI 使用指令提供的问题进行自我评估：

核心问题：

1. 这是否涉及编码或项目状态更改？

   • 编码和项目管理是统一的 — 编写代码会自动触发文件跟踪、数据库更新和任务进度
   • FP 基线始终作为强制编码风格处于活动状态
   • 项目指令处理跟踪方面（文件写入、数据库更新、任务管理）

2. 我是否在内存中有指令？

   • 否：通过 aifp_run(is_new_session=true) 从会话包中加载
   • 是：使用缓存的指令继续

3. 哪些指令适用？

   • FP 基线：强制编码风格（纯函数、不可变性、无 OOP） — 自然应用，不作为指令调用
   • FP 指令：仅作为参考文档 — 在不确定复杂场景时查阅
   • 项目指令：文件写入、数据库更新、任务管理

4. 是否需要行动 - 反应？

   • 代码写入 → project_file_write 指令 → 数据库更新
   • 文件编辑 → 数据库同步
   • 带有决策的讨论 → 数据库更新

示例流程（编码任务）：

用户："编写 multiply_matrices 函数"
AI 思考：
  ✓ FP 基线适用（编写纯、不可变、无 OOP 的代码）
  ✓ 项目跟踪适用（`project_file_write` 指令）
  ✓ 我在内存中有指令

AI 执行：
  1. 自然地编写遵循 FP 基线的函数
  2. 应用 `project_file_write` 指令
  3. 更新 `project.db`（文件、函数、交互）

4. 指令执行

指令遵循 主干 → 分支 → 回退 模式：

{
  "trunk": "analyze_function",
  "branches": [
    {"if": "pure_function", "then": "mark_compliant"},
    {"if": "mutation_detected", "then": "refactor_to_pure"},
    {"if": "low_confidence", "then": "prompt_user"},
    {"fallback": "prompt_user"}
  ]
}

项目生命周期

graph TD
    A[aifp_init] --> B[project_discovery]
    B --> C[project_progression]
    C --> D[project_file_write]
    D --> E[project_update_db]
    E --> F{所有项目完成？}
    F -->|否| D
    F -->|是| G[project_task_complete]
    G --> H{所有任务完成？}
    H -->|否| C
    H -->|是| I[project_milestone_complete]
    I --> J{所有里程碑完成？}
    J -->|否| C
    J -->|是| K[project_completion_check]
    K --> L[project_archive]

📄 许可证

本项目采用 MIT 许可证，详情请见 LICENSE。