Metadata-Version: 2.4
Name: fgeo
Version: 1.0.0
Summary: fgeo — Generative Engine Optimization CLI. AI-powered content asset management and multi-platform distribution.
Author: MarvinTalk
License-Expression: MIT
Keywords: geo,seo,ai,content,cli,agent
Requires-Python: >=3.10
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: typer>=0.12.0
Requires-Dist: rich>=13.0.0
Requires-Dist: pydantic>=2.0.0
Requires-Dist: pyyaml>=6.0
Requires-Dist: atproto>=0.0.54
Provides-Extra: test
Requires-Dist: pytest>=7.0; extra == "test"
Requires-Dist: pytest-cov>=5.0; extra == "test"
Provides-Extra: dev
Requires-Dist: ruff; extra == "dev"
Requires-Dist: pytest>=7.0; extra == "dev"
Requires-Dist: pytest-cov>=5.0; extra == "dev"
Requires-Dist: build; extra == "dev"
Provides-Extra: ai
Requires-Dist: litellm>=1.0.0; extra == "ai"
Provides-Extra: publish
Requires-Dist: playwright>=1.40.0; extra == "publish"
Requires-Dist: httpx>=0.27.0; extra == "publish"
Dynamic: license-file

# fgeo

**Languages:** English | [简体中文](README.zh-CN.md)

fgeo is not just a software system.

It is a learning methodology, packaged as an out-of-the-box agent skill, that
helps you turn real work into growth.

fgeo is built around one formula:

```text
User Growth = Action x Feedback x Adaptation
```

You grow when you do something real, receive meaningful feedback, and change the
next attempt.

## What fgeo Is

fgeo is a local-first growth companion for AI-assisted work.

It helps an agent understand your goal, route the work to the right skill, and
keep the learning loop alive:

```text
Action -> Feedback -> Adaptation
```

The CLI provides the local state boundary. The agent skills provide the
methodology and workflow guidance.

Together, they help you:

- understand your current level and what is worth improving next,
- practice through small real attempts,
- turn learning into reusable records, cases, and content,
- publish content and route real-world signals back into learning,
- avoid starting from zero every time you open a new agent session.

## Why the Formula Matters

The formula uses multiplication because any missing part breaks the loop:

- Action without Feedback becomes blind repetition.
- Feedback without Action becomes analysis without experience.
- Action plus Feedback without Adaptation becomes awareness without growth.

Time and memory are not the formula itself. Time only matters when useful loops
repeat. Memory helps fgeo preserve prior signals, reuse context, and time the
next loop so each session does not start from zero.

## fgeo Agent Skills

fgeo routes user intent into one primary workflow at a time:

```text
need clarity / current level / review / feedback meaning -> fgeo-digest
need practice / improvement / mastery / next attempt     -> fgeo-growth
need expression / draft / story / case / article         -> fgeo-content
need publish / external signal / metrics / reply         -> fgeo-publish
need identity / audience / preference / boundary         -> fgeo-profile
```

Each skill supports a different part of the learning loop:

| Skill | Role |
| --- | --- |
| `fgeo-digest` | Interprets what happened, what is clear, what is shaky, and what feedback means. |
| `fgeo-growth` | Turns goals or gaps into small practice, review, and the next better attempt. |
| `fgeo-content` | Turns learning, evidence, cases, and methods into platform-native expression. |
| `fgeo-publish` | Publishes tracked content and routes real-world signals back into learning. |
| `fgeo-profile` | Preserves identity, preferences, audience, boundaries, and long-term context. |

## Why This Matters

Most AI tools help with a single task:

```text
summarize this
write this
publish this
fix this
```

fgeo tries to help with continuous growth:

```text
What did I do?
What feedback appeared?
What did I not notice?
What should I absorb?
What should change next time?
```

The feedback loop is not a closing CTA. It is the core learning mechanism.
fgeo should help the user notice signals they missed, absorb those signals, and
turn them into the next action.

## CLI Quick Start

Install and initialize fgeo:

```bash
pip install fgeo

fgeo init
fgeo enable codex
```

Create a project and publishing workflow:

```bash
fgeo project create fcontext --desc "AI context manager"
fgeo goal add fcontext "Help developers understand fcontext"
fgeo platform add fcontext devto --directions "tutorial,architecture" --pace "2/month"
fgeo plan create fcontext cold-start --strategy "Developer community launch"
fgeo plan assign fcontext cold-start devto --direction tutorial --target 3
```

Register content:

```bash
fgeo content register docs/first-post.md \
  --project fcontext \
  --platform devto \
  --plan cold-start \
  --direction tutorial \
  --type article \
  --status draft
```

Check status:

```bash
fgeo status fcontext
```

## What the CLI Manages

The CLI keeps stable local state for the agent skills:

```text
Profile -> Digest -> Growth -> Content -> Publish -> Feedback
```

It can track projects, goals, plans, platforms, content assets, publish tasks,
learning records, evidence, gaps, baselines, and feedback signals.

The important point is not the database. The important point is that the agent
does not lose the learning loop between sessions.

## Supported Agent Integrations

`fgeo enable <agent>` writes fgeo instructions into each agent's native location
and also enables fcontext for the same workspace.

Supported agents:

```text
copilot, claude, cursor, trae, qwen, kiro, opencode,
openclaw, zed, pi, antigravity, codex
```
