everythingiscontext 0.1.0__py3-none-any.whl

core/__init__.py

@@ -0,0 +1 @@
+# empty package marker

core/kind_specs.py

@@ -0,0 +1,135 @@
+"""Per-kind module structure: required files, default growth folders, purpose.
+
+Single source of truth for how an `integration`, `task`, or `workflow`
+module is laid out on disk.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class KindSpec:
+    kind: str
+    purpose: str
+    required_files: list[str]
+    starter_file: str
+    starter_outline: str
+    default_growth_folders: list[dict]  # [{"name": "notes", "path": "notes/<date-slug>.md"}]
+
+
+KIND_SPECS: dict[str, KindSpec] = {
+    "integration": KindSpec(
+        kind="integration",
+        purpose="Reusable access to an external service, API, database, or local tool.",
+        required_files=["module.yaml", "llms.txt", "info.md"],
+        starter_file="info.md",
+        starter_outline="Purpose, Access, Operations, Example usage.",
+        default_growth_folders=[
+            {"name": "notes", "path": "notes/<date-slug>.md"},
+        ],
+    ),
+    "task": KindSpec(
+        kind="task",
+        purpose="A bounded outcome needing progress tracking, subtasks, findings.",
+        required_files=["module.yaml", "llms.txt", "brief.md", "status.md"],
+        starter_file="brief.md",
+        starter_outline="Goal and initial request; status.md tracks subtasks.",
+        default_growth_folders=[
+            {"name": "progress", "path": "progress/<date-slug>.md"},
+        ],
+    ),
+    "workflow": KindSpec(
+        kind="workflow",
+        purpose="A repeatable procedure or playbook that should improve across runs.",
+        required_files=["module.yaml", "llms.txt", "steps.md"],
+        starter_file="steps.md",
+        starter_outline="The repeatable steps, numbered.",
+        default_growth_folders=[
+            {"name": "runs", "path": "runs/<date-slug>.md"},
+            {"name": "lessons", "path": "lessons/<date-slug>.md"},
+        ],
+    ),
+}
+
+
+def render_kind_specs_md() -> str:
+    """Render KIND_SPECS as markdown for structure.md."""
+    lines: list[str] = []
+    for spec in KIND_SPECS.values():
+        lines.append(f"### `{spec.kind}`")
+        lines.append("")
+        lines.append(spec.purpose)
+        lines.append("")
+        lines.append("**Files written at creation:**")
+        for f in spec.required_files:
+            note = f" - {spec.starter_outline}" if f == spec.starter_file else ""
+            lines.append(f"- `{f}`{note}")
+        if spec.default_growth_folders:
+            lines.append("")
+            lines.append(
+                "**Default growth folders** (lazy: created on first entry; "
+                "seed these into `llms.txt` `## Where to write` at module creation):"
+            )
+            for ga in spec.default_growth_folders:
+                lines.append(f"- `{ga['name']}` -> `{ga['path']}`")
+        lines.append("")
+    return "\n".join(lines)
+
+
+@dataclass(frozen=True)
+class InfoSection:
+    name: str
+    purpose: str
+    format: str  # "freeform" or description of strict format
+
+
+# Core version: 6 sections (no "Python packages" — that's added by Context Agora)
+INTEGRATION_INFO_SECTIONS: list[InfoSection] = [
+    InfoSection(
+        "Purpose",
+        "One-line summary of what this integration gives the agent access to.",
+        "freeform",
+    ),
+    InfoSection(
+        "Where it lives",
+        "Upstream system: URL, host, endpoint, or local path.",
+        "freeform",
+    ),
+    InfoSection(
+        "Auth & access",
+        "How the agent authenticates. Required secret names are written as `UPPER_CASE` in backticks.",
+        "strict: secret names as `UPPER_CASE` backtick tokens",
+    ),
+    InfoSection(
+        "Key entities",
+        "Domain objects the agent can read or write.",
+        "freeform",
+    ),
+    InfoSection(
+        "Operations",
+        "Common calls or queries with short examples.",
+        "freeform",
+    ),
+    InfoSection(
+        "Examples",
+        "Runnable snippets.",
+        "freeform",
+    ),
+]
+
+
+def render_info_md_sections_md(sections: list[InfoSection] | None = None) -> str:
+    """Render the integration kind's expected info.md sections for structure.md.
+
+    Accepts an optional sections list so the platform can pass an extended
+    list (e.g., with "Python packages" section). Defaults to core's 6-section list.
+    """
+    sections = sections or INTEGRATION_INFO_SECTIONS
+    lines: list[str] = ["### `info.md` sections (integration kind)", ""]
+    for s in sections:
+        lines.append(f"- `## {s.name}` -- {s.purpose}")
+        if s.format != "freeform":
+            lines.append(f"  - Format: {s.format}")
+    lines.append("")
+    return "\n".join(lines)

core/llms_gen.py

@@ -0,0 +1,109 @@
+"""Generate workspace-level files: llms.txt, system.md, structure.md.
+
+These files are regenerated on every load/unload operation.
+"""
+import logging
+from pathlib import Path
+
+import yaml
+
+from core.kind_specs import render_kind_specs_md, render_info_md_sections_md
+from core.manifest import render_schema_md
+
+log = logging.getLogger(__name__)
+
+
+def extract_module_summary(llms_txt_content: str) -> str:
+    """Extract the > blockquote description from a module's llms.txt."""
+    for line in llms_txt_content.splitlines():
+        if line.startswith("> "):
+            return line[2:].strip()
+    return ""
+
+
+def generate_root_llms_txt(context_dir: Path) -> None:
+    """Generate root llms.txt from loaded modules' llms.txt files.
+
+    Skips dot-prefixed directories (e.g. .claude).
+    """
+    entries = []
+    for mod_dir in sorted(context_dir.iterdir()):
+        if not mod_dir.is_dir() or mod_dir.name.startswith("."):
+            continue
+        llms_file = mod_dir / "llms.txt"
+        if llms_file.exists():
+            summary = extract_module_summary(llms_file.read_text())
+        else:
+            summary = "Context module"
+        entries.append(f"- [{mod_dir.name}]({mod_dir.name}/llms.txt): {summary}")
+
+    lines = ["# Context", ""]
+    lines.extend(entries)
+    (context_dir / "llms.txt").write_text("\n".join(lines) + "\n")
+
+
+def generate_structure_md(context_dir: Path, info_sections: list | None = None) -> None:
+    """Write context/structure.md from manifest schema and kind specs.
+
+    Auto-generated reference for module.yaml fields, per-kind file
+    requirements, and info.md section structure.
+
+    Accepts optional info_sections so the platform can pass its extended
+    list (with "Python packages" section). Defaults to core's 6-section list.
+    """
+    body = "\n".join([
+        "# Module Structure",
+        "",
+        "Auto-generated from `manifest.py` and `kind_specs.py`. Do not edit by hand.",
+        "",
+        render_schema_md(),
+        "",
+        "## Module kinds",
+        "",
+        render_kind_specs_md(),
+        "## Starter file structure",
+        "",
+        render_info_md_sections_md(info_sections),
+    ])
+    (context_dir / "structure.md").write_text(body)
+
+
+def generate_system_md(context_dir: Path, template_content: str) -> None:
+    """Write context/system.md from a template string + loaded modules table.
+
+    The caller is responsible for reading/assembling the template content.
+    This function appends the loaded modules table at the end.
+    Skips dot-prefixed directories.
+    """
+    rows: list[tuple[str, str, str]] = []
+    for mod_dir in sorted(context_dir.iterdir()):
+        if not mod_dir.is_dir() or mod_dir.name.startswith("."):
+            continue
+        kind = "unknown"
+        manifest_file = mod_dir / "module.yaml"
+        if manifest_file.exists():
+            try:
+                data = yaml.safe_load(manifest_file.read_text())
+                kind = data.get("kind", "integration") if data else "unknown"
+            except Exception:
+                log.warning("Failed to parse %s", manifest_file)
+        llms_file = mod_dir / "llms.txt"
+        summary = ""
+        if llms_file.exists():
+            summary = extract_module_summary(llms_file.read_text())
+        rows.append((mod_dir.name, kind, summary))
+
+    lines = [
+        "",
+        "## Loaded modules",
+        "",
+    ]
+    if rows:
+        lines.append("| Module | Kind | Summary |")
+        lines.append("|--------|------|---------|")
+        for name, kind, summary in rows:
+            lines.append(f"| {name} | {kind} | {summary} |")
+    else:
+        lines.append("No modules loaded.")
+
+    (context_dir / "system.md").write_text(template_content + "\n".join(lines) + "\n")

core/manifest.py

@@ -0,0 +1,225 @@
+"""Module manifest (module.yaml) read/write service.
+
+Each module declares its name, kind, secrets, dependencies, and optional
+jobs in module.yaml. Replaces per-module .env.schema and requirements.txt.
+"""
+import re
+import typing
+from pathlib import Path
+from typing import Literal
+
+import yaml
+from pydantic import BaseModel, Field, field_validator
+
+ModuleKind = Literal["integration", "task", "workflow"]
+
+
+_EVERY_RE = re.compile(r"^(\d+)([smh])$")
+_EVERY_UNIT_SECONDS = {"s": 1, "m": 60, "h": 3600}
+
+# Must match jobs.TICK_SECONDS — keep as a constant here to avoid
+# importing jobs.py from manifest.py (circular).
+_MIN_EVERY_SECONDS = 30
+
+
+def parse_every(value: str) -> int:
+    """Convert '30s' / '5m' / '1h' to a number of seconds.
+
+    Raises ValueError on any malformed input or values below the
+    scheduler tick (30 s) — sub-tick intervals would round up anyway
+    and surprise the user.
+    """
+    if not isinstance(value, str):
+        raise ValueError(f"every must be a string, got {type(value).__name__}")
+    match = _EVERY_RE.fullmatch(value)
+    if not match:
+        raise ValueError(
+            f"invalid every '{value}': expected <digits><s|m|h>, e.g. '30s', '5m', '1h'"
+        )
+    n = int(match.group(1))
+    if n == 0:
+        raise ValueError(f"invalid every '{value}': must be > 0")
+    seconds = n * _EVERY_UNIT_SECONDS[match.group(2)]
+    if seconds < _MIN_EVERY_SECONDS:
+        raise ValueError(
+            f"invalid every '{value}': minimum is {_MIN_EVERY_SECONDS}s"
+        )
+    return seconds
+
+
+class JobSpec(BaseModel):
+    name: str = Field(..., description="Job identifier; unique within the module.")
+    script: str = Field(
+        ...,
+        description="Relative path to the script inside the module directory. Absolute paths and `..` traversal are rejected.",
+    )
+    every: str = Field(
+        ...,
+        description="Cron-like cadence as `<digits><s|m|h>` (e.g. `30s`, `5m`, `1h`). Minimum 30s.",
+    )
+
+    @field_validator("script")
+    @classmethod
+    def _no_absolute_or_traversal(cls, v: str) -> str:
+        if v.startswith("/") or ".." in Path(v).parts:
+            raise ValueError(f"invalid script path '{v}': must be relative inside the module")
+        return v
+
+    @field_validator("every")
+    @classmethod
+    def _validate_every(cls, v: str) -> str:
+        parse_every(v)  # raises on bad values
+        return v
+
+    @property
+    def every_seconds(self) -> int:
+        return parse_every(self.every)
+
+
+class ModuleManifest(BaseModel):
+    name: str = Field(
+        ...,
+        description="Folder slug; must match the module directory name.",
+    )
+    kind: ModuleKind = Field(
+        default="integration",
+        description='One of: "integration", "task", "workflow". Drives how the module is rendered in the sidebar.',
+    )
+    archived: bool = Field(
+        default=False,
+        description="Hide from the active sidebar without deleting. Archived modules appear under a collapsed Archived section and cannot be loaded into the workspace.",
+    )
+    secrets: list[str] = Field(
+        default_factory=list,
+        description="Environment variable names this module needs at runtime. Resolved via varlock from the workspace .env.schema.",
+    )
+    dependencies: list[str] = Field(
+        default_factory=list,
+        description="Python packages required at runtime. Installed into the platform venv at boot.",
+    )
+    icon: str = Field(
+        default="",
+        description="Icon name for the module's app card (e.g. 'globe', 'server'). Empty means auto-derived.",
+    )
+    jobs: list[JobSpec] = Field(
+        default_factory=list,
+        description="Cron-like scheduled scripts owned by this module.",
+    )
+
+
+def read_manifest(module_dir: Path) -> ModuleManifest:
+    """Read module.yaml from a module directory.
+
+    Returns a manifest with defaults (name inferred from dir) if the
+    file doesn't exist.
+    """
+    manifest_path = module_dir / "module.yaml"
+    if not manifest_path.exists():
+        return ModuleManifest(name=module_dir.name)
+    raw = yaml.safe_load(manifest_path.read_text()) or {}
+    raw.setdefault("name", module_dir.name)
+    return ModuleManifest(**raw)
+
+
+def write_manifest(module_dir: Path, manifest: ModuleManifest) -> None:
+    """Write a ModuleManifest to module.yaml, omitting empty optional fields."""
+    data: dict[str, str | bool | list[str]] = {"name": manifest.name}
+    if manifest.kind != "integration":
+        data["kind"] = manifest.kind
+    if manifest.archived:
+        data["archived"] = manifest.archived
+    if manifest.icon:
+        data["icon"] = manifest.icon
+    if manifest.secrets:
+        data["secrets"] = manifest.secrets
+    if manifest.dependencies:
+        data["dependencies"] = manifest.dependencies
+    if manifest.jobs:
+        data["jobs"] = [
+            {"name": j.name, "script": j.script, "every": j.every}
+            for j in manifest.jobs
+        ]
+    (module_dir / "module.yaml").write_text(
+        yaml.dump(data, default_flow_style=False, sort_keys=False)
+    )
+
+
+_SLUG_NON_ALPHANUM = re.compile(r"[^a-z0-9-]")
+_SLUG_DASH_RUN = re.compile(r"-+")
+
+
+def slugify_task_name(name: str) -> str:
+    """Convert a human task name to a folder-safe slug."""
+    slug = name.strip().lower().replace("_", "-")
+    slug = _SLUG_NON_ALPHANUM.sub("-", slug)
+    slug = _SLUG_DASH_RUN.sub("-", slug)
+    return slug.strip("-")
+
+
+_PRIMITIVE_NAMES = {
+    str: "str",
+    int: "int",
+    float: "float",
+    bool: "bool",
+}
+
+
+def _format_default(field) -> str:
+    if field.is_required():
+        return "required"
+    factory = field.default_factory
+    if factory is not None:
+        try:
+            default = factory()
+        except TypeError:
+            default = None
+    else:
+        default = field.default
+    if isinstance(default, bool):
+        return "default false" if default is False else "default true"
+    if isinstance(default, str):
+        return f'default "{default}"'
+    if isinstance(default, list) and not default:
+        return "default []"
+    return f"default {default!r}"
+
+
+def _format_type(annotation) -> str:
+    if annotation in _PRIMITIVE_NAMES:
+        return _PRIMITIVE_NAMES[annotation]
+    origin = getattr(annotation, "__origin__", None)
+    if origin is list:
+        (inner,) = annotation.__args__
+        if inner is JobSpec:
+            return "list[JobSpec]"
+        return f"list[{_PRIMITIVE_NAMES.get(inner, inner.__name__)}]"
+    if typing.get_origin(annotation) is Literal:
+        return " | ".join(repr(v) for v in typing.get_args(annotation))
+    return getattr(annotation, "__name__", str(annotation))
+
+
+def render_schema_md() -> str:
+    """Render ModuleManifest as a markdown schema block for prompt injection.
+
+    Walks the model's fields and emits one bullet per field with type,
+    default, and description. Single source of truth for what the AI
+    should write into module.yaml — adding a new field here makes it
+    visible to the chat agent automatically.
+    """
+    lines = ["## module.yaml schema", ""]
+    for field_name, field in ModuleManifest.model_fields.items():
+        type_str = _format_type(field.annotation)
+        default_str = _format_default(field)
+        desc = field.description or ""
+        lines.append(f"- `{field_name}` ({type_str}, {default_str}) — {desc}")
+        if type_str == "list[JobSpec]":
+            for sub_name, sub in JobSpec.model_fields.items():
+                sub_type = _format_type(sub.annotation)
+                sub_default = _format_default(sub)
+                sub_desc = sub.description or ""
+                lines.append(f"  - `{sub_name}` ({sub_type}, {sub_default}) — {sub_desc}")
+    lines.append("")
+    lines.append(
+        "Omit fields that match their default. Unknown fields are rejected."
+    )
+    return "\n".join(lines)

core/schemas.py

@@ -0,0 +1,22 @@
+import re
+
+_VALID_MODULE_NAME = re.compile(r"^[a-zA-Z0-9][a-zA-Z0-9_-]*$")
+
+
+def validate_module_name(name: str) -> str:
+    name = name.strip()
+    if not name or not _VALID_MODULE_NAME.match(name):
+        raise ValueError(
+            f"Invalid module name: '{name}'. "
+            "Must start with a letter or number, then letters, numbers, hyphens, underscores."
+        )
+    return name
+
+
+def validate_module_file_path(file_path: str) -> str:
+    file_path = file_path.strip().strip("/")
+    if not file_path:
+        raise ValueError("File path cannot be empty")
+    if ".." in file_path:
+        raise ValueError("File path cannot contain '..'")
+    return file_path

core/templates/module_features.md

@@ -0,0 +1,9 @@
+# Module Features — Optional Capabilities
+
+A module is just a folder. Beyond `module.yaml` + `llms.txt` + the kind's starter file (info.md / brief.md / steps.md), a module can optionally carry:
+
+## Scripts
+
+Plain Python files inside the module that the agent can run on demand. The canonical example is `verify.py` — a quick sanity check that the integration's credentials and network access work.
+
+When to add one: when the module benefits from a repeatable check, fetch, or transformation that the user (or another turn) will want to invoke later.

core/templates/principles.md

@@ -0,0 +1,29 @@
+# Principles — Modifying Context
+
+These are the rules for creating, editing, or extending modules.
+
+## Module locations
+
+Modules live at `modules-repo/<slug>/`. The `context/` directory contains symlinks for the subset of modules currently loaded into the active workspace — **it is a view, not a storage location.**
+
+Two operations that look similar but are NOT the same:
+
+- **Create / edit a module.** You write files at `modules-repo/<slug>/...`. This is the only kind of write you perform.
+- **Load a module into the workspace.** This creates a symlink inside `context/`. It is managed by `eic.py`, not by you.
+
+Each module is a folder with at least `module.yaml` and `llms.txt`.
+
+## Reading context before modifying
+
+Before answering anything that references or implies a topic likely covered by an existing module, read that module's `llms.txt` first. If `llms.txt` declares a `## Where to write` section, that section governs where any subsequent appends go (path, naming pattern, template). Do NOT invent a new location.
+
+If no module matches, you may answer from general knowledge — but if the conversation produces durable content (a finding, a note worth keeping, a new procedure), propose a new module rather than silently dropping it.
+
+## Module schema and kinds
+
+See [structure.md](structure.md) for the authoritative module.yaml schema and the per-kind file layout (integration / task / workflow). That file is auto-generated from code — read it; do not invent fields.
+
+## When to propose a new module vs append to an existing one
+
+- **Append** when the content is one more instance of a pattern the module already tracks (another note, another run, another finding).
+- **New module** when the content concerns a different external service, a different task with its own goal, or a different repeatable procedure. New modules cost almost nothing — favor a small new module over stretching an existing one.

core/templates/system.md

@@ -0,0 +1,40 @@
+# System
+
+You are an AI agent powered by loaded context modules.
+
+You are direct, efficient, and familiar with the loaded context. No hedging, no filler. Lead with the answer.
+
+## Two responsibilities
+
+1. **Operate modules** — read context, run scripts, answer questions. This file covers that.
+2. **Modify context** — create or edit modules. See [principles.md](principles.md) before doing this.
+
+## How to operate a module
+
+**CRITICAL: Assume every question is potentially answerable through your modules. Always navigate the `llms.txt` tree before claiming you can't help. Never dismiss a question as out of scope without checking first.**
+
+When asked anything, start by asking: **"Which module do I need?"**
+
+1. Read `llms.txt` — see all loaded modules with one-line descriptions
+2. Pick the relevant module(s) based on the question
+3. Read that module's `llms.txt` to find the specific file you need
+4. Read the actual content, write a script if needed, and get the answer
+
+## Setup per turn
+
+1. Read [llms.txt](llms.txt) — orient yourself in the module hierarchy
+2. For any module you need, read its `module.yaml` — declares required secrets and dependencies
+
+## Secrets
+
+See [secrets.md](secrets.md) for how secrets work in this environment.
+
+A module needs secrets if and only if its `module.yaml` declares a `secrets:` list (variable names only, no values).
+
+## Module features (optional capabilities)
+
+Modules can expose scripts and other capabilities. See [module_features.md](module_features.md) for the catalog.
+
+## Modifying context
+
+If you are asked to create a new module, edit a module's files, or change anything in `modules-repo/<slug>/`, read [principles.md](principles.md) first. It owns the rules for where things go and how writes are gated.

eic/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

eic/cli.py

@@ -0,0 +1,446 @@
+#!/usr/bin/env python3
+"""eic — Everything Is Context module manager.
+
+Usage:
+    eic init
+    eic new <kind> <name>
+    eic load <name> [name2 ...]
+    eic unload <name>
+    eic ls
+    eic env
+    eic validate [name]
+"""
+import argparse
+import importlib.resources
+import os
+import re
+import sys
+from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# Paths — all relative to CWD (the user's project directory)
+# ---------------------------------------------------------------------------
+MODULES_DIR = Path.cwd() / "modules-repo"
+CONTEXT_DIR = Path.cwd() / "context"
+
+# ---------------------------------------------------------------------------
+# Package-data helpers
+# ---------------------------------------------------------------------------
+
+def _read_pkg_text(package: str, *path_parts: str) -> str:
+    """Read a text file bundled inside a Python package."""
+    return importlib.resources.files(package).joinpath(*path_parts).read_text()
+
+
+def _copy_pkg_file(package: str, path_parts: tuple[str, ...], dest: Path) -> None:
+    """Copy a text file from package data to a filesystem path."""
+    src = importlib.resources.files(package).joinpath(*path_parts)
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    dest.write_text(src.read_text())
+
+
+# ---------------------------------------------------------------------------
+# Imports from the core package (installed alongside eic)
+# ---------------------------------------------------------------------------
+from core.manifest import ModuleManifest, read_manifest, write_manifest
+from core.kind_specs import KIND_SPECS, INTEGRATION_INFO_SECTIONS
+from core.schemas import validate_module_name
+from core.llms_gen import generate_root_llms_txt, generate_structure_md, generate_system_md
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+def _copy_static_files():
+    """Copy static template files into context/."""
+    for name in ["principles.md", "module_features.md"]:
+        _copy_pkg_file("core", ("templates", name), CONTEXT_DIR / name)
+    _copy_pkg_file("eic", ("data", "secrets.md"), CONTEXT_DIR / "secrets.md")
+
+
+def _regenerate():
+    """Regenerate all auto-generated files in context/."""
+    template_content = _read_pkg_text("core", "templates", "system.md")
+    generate_root_llms_txt(CONTEXT_DIR)
+    generate_structure_md(CONTEXT_DIR)
+    generate_system_md(CONTEXT_DIR, template_content)
+    _copy_static_files()
+    _generate_env_example()
+
+
+def _generate_env_example():
+    """Generate .env.example from all loaded modules' secrets lists."""
+    lines = []
+    for mod_dir in sorted(CONTEXT_DIR.iterdir()):
+        if not mod_dir.is_dir() or mod_dir.name.startswith("."):
+            continue
+        manifest = read_manifest(mod_dir)
+        if manifest.secrets:
+            lines.append(f"# {manifest.name}")
+            for secret in manifest.secrets:
+                lines.append(f"{secret}=")
+            lines.append("")
+    env_example = Path.cwd() / ".env.example"
+    if lines:
+        env_example.write_text("\n".join(lines) + "\n")
+    elif env_example.exists():
+        env_example.unlink()
+
+
+# ---------------------------------------------------------------------------
+# Commands
+# ---------------------------------------------------------------------------
+
+_EXAMPLE_FILES = ["module.yaml", "llms.txt", "info.md"]
+
+
+def cmd_init(args):
+    """Initialize the workspace."""
+    MODULES_DIR.mkdir(exist_ok=True)
+    CONTEXT_DIR.mkdir(exist_ok=True)
+
+    # Seed the example module when modules-repo is empty
+    if not any(MODULES_DIR.iterdir()):
+        example_dest = MODULES_DIR / "example"
+        example_dest.mkdir(parents=True, exist_ok=True)
+        for fname in _EXAMPLE_FILES:
+            _copy_pkg_file("eic", ("data", "example", fname), example_dest / fname)
+
+    # Create .gitignore if it doesn't exist
+    gitignore = Path.cwd() / ".gitignore"
+    if not gitignore.exists():
+        gitignore.write_text(".env\n")
+    else:
+        content = gitignore.read_text()
+        if ".env" not in content.splitlines():
+            gitignore.write_text(content.rstrip("\n") + "\n.env\n")
+
+    _regenerate()
+    print("Created modules-repo/")
+    print("Created context/")
+    print("Ready. Create your first module with: eic new integration <name>")
+
+
+def cmd_new(args):
+    """Scaffold a new module."""
+    kind = args.kind
+    name = args.name
+
+    if kind not in KIND_SPECS:
+        print(f"Error: unknown kind '{kind}'. Must be one of: {', '.join(KIND_SPECS.keys())}")
+        sys.exit(1)
+
+    try:
+        name = validate_module_name(name)
+    except ValueError as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+    mod_dir = MODULES_DIR / name
+    if mod_dir.exists():
+        print(f"Error: module '{name}' already exists at {mod_dir}")
+        sys.exit(1)
+
+    mod_dir.mkdir(parents=True)
+    spec = KIND_SPECS[kind]
+
+    # Write module.yaml
+    manifest = ModuleManifest(name=name, kind=kind)
+    write_manifest(mod_dir, manifest)
+
+    # Write llms.txt
+    starter_desc = spec.starter_outline
+    llms_content = f"# {name}\n\n> One-line summary of this module\n\n"
+    llms_content += f"- [{spec.starter_file}]({spec.starter_file}): {starter_desc}\n"
+    llms_content += "- [module.yaml](module.yaml): Module configuration\n"
+    (mod_dir / "llms.txt").write_text(llms_content)
+
+    # Write starter file(s)
+    if kind == "integration":
+        sections = []
+        for s in INTEGRATION_INFO_SECTIONS:
+            sections.append(f"## {s.name}\n{s.purpose}\n")
+        (mod_dir / "info.md").write_text(f"# {name}\n\n" + "\n".join(sections))
+
+    elif kind == "task":
+        (mod_dir / "brief.md").write_text(
+            f"# {name}\n\n## Goal\nWhat this task should accomplish.\n\n## Context\nBackground and constraints.\n"
+        )
+        (mod_dir / "status.md").write_text(
+            "# Status\n\n## Subtasks\n- [ ] First subtask\n"
+        )
+
+    elif kind == "workflow":
+        (mod_dir / "steps.md").write_text(
+            f"# {name}\n\n## Steps\n1. First step\n2. Second step\n"
+        )
+
+    for f in spec.required_files:
+        print(f"Created modules-repo/{name}/{f}")
+    print(f'Module "{name}" created. Edit the files, then load it with: eic load {name}')
+
+
+def cmd_load(args):
+    """Load modules into the workspace via symlinks."""
+    if not CONTEXT_DIR.exists():
+        print("Error: workspace not initialized. Run: eic init")
+        sys.exit(1)
+
+    for name in args.names:
+        mod_source = MODULES_DIR / name
+        if not mod_source.is_dir():
+            print(f"Error: module '{name}' not found in modules-repo/")
+            sys.exit(1)
+
+        link_path = CONTEXT_DIR / name
+        if link_path.is_symlink() or link_path.exists():
+            print(f"Already loaded: {name}")
+            continue
+
+        # Relative symlink for portability
+        link_path.symlink_to(Path("..") / "modules-repo" / name)
+        print(f"Loaded {name}")
+
+    _regenerate()
+    loaded_count = sum(1 for p in CONTEXT_DIR.iterdir() if p.is_symlink())
+    print(f"Regenerated context/ ({loaded_count} modules)")
+
+
+def cmd_unload(args):
+    """Remove a module from the workspace."""
+    name = args.name
+    link_path = CONTEXT_DIR / name
+
+    if not link_path.is_symlink():
+        print(f"Error: '{name}' is not loaded")
+        sys.exit(1)
+
+    link_path.unlink()
+    print(f"Unloaded {name}")
+
+    _regenerate()
+    loaded_count = sum(1 for p in CONTEXT_DIR.iterdir() if p.is_symlink())
+    print(f"Regenerated context/ ({loaded_count} modules)")
+
+
+def cmd_ls(args):
+    """List all modules and their status."""
+    if not MODULES_DIR.exists():
+        print("No modules-repo/ directory. Run: eic init")
+        return
+
+    loaded_names = set()
+    if CONTEXT_DIR.exists():
+        loaded_names = {p.name for p in CONTEXT_DIR.iterdir() if p.is_symlink()}
+
+    all_modules = sorted(p.name for p in MODULES_DIR.iterdir() if p.is_dir())
+
+    if not all_modules:
+        print("No modules found. Create one with: eic new integration <name>")
+        return
+
+    loaded = [(n, read_manifest(MODULES_DIR / n)) for n in all_modules if n in loaded_names]
+    available = [(n, read_manifest(MODULES_DIR / n)) for n in all_modules if n not in loaded_names]
+
+    from core.llms_gen import extract_module_summary
+
+    def _summary(name):
+        llms_file = MODULES_DIR / name / "llms.txt"
+        if llms_file.exists():
+            return extract_module_summary(llms_file.read_text())
+        return ""
+
+    if loaded:
+        print("LOADED")
+        for name, m in loaded:
+            summary = _summary(name)
+            print(f"  {name:<20s} {m.kind:<14s} {summary}")
+        print()
+
+    if available:
+        print("AVAILABLE")
+        for name, m in available:
+            summary = _summary(name)
+            print(f"  {name:<20s} {m.kind:<14s} {summary}")
+
+
+def cmd_env(args):
+    """Check which secret variables are set or missing."""
+    if not CONTEXT_DIR.exists():
+        print("Error: workspace not initialized. Run: eic init")
+        sys.exit(1)
+
+    # Try to load .env file into a dict (don't inject into os.environ)
+    env_vars = dict(os.environ)
+    env_file = Path.cwd() / ".env"
+    if env_file.exists():
+        for line in env_file.read_text().splitlines():
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            if "=" in line:
+                key, _, value = line.partition("=")
+                env_vars[key.strip()] = value.strip()
+
+    any_missing = False
+    any_secrets = False
+
+    for mod_dir in sorted(CONTEXT_DIR.iterdir()):
+        if not mod_dir.is_dir() or mod_dir.name.startswith("."):
+            continue
+        manifest = read_manifest(mod_dir)
+        if not manifest.secrets:
+            continue
+        any_secrets = True
+        print(f"\n{manifest.name}")
+        for secret in manifest.secrets:
+            if secret in env_vars and env_vars[secret]:
+                print(f"  {secret:<30s} set")
+            else:
+                print(f"  {secret:<30s} missing")
+                any_missing = True
+
+    if not any_secrets:
+        print("No loaded modules declare secrets.")
+        return
+
+    if any_missing:
+        print("\nMissing variables. Add them to .env")
+        sys.exit(1)
+    else:
+        print("\nAll variables set.")
+
+
+def cmd_validate(args):
+    """Validate module structure."""
+    if args.name:
+        names = [args.name]
+    else:
+        if not MODULES_DIR.exists():
+            print("No modules-repo/ directory.")
+            sys.exit(1)
+        names = sorted(p.name for p in MODULES_DIR.iterdir() if p.is_dir())
+
+    if not names:
+        print("No modules to validate.")
+        return
+
+    all_pass = True
+    for name in names:
+        mod_dir = MODULES_DIR / name
+        if not mod_dir.is_dir():
+            print(f"{name}  FAIL  module directory not found")
+            all_pass = False
+            continue
+
+        errors = []
+        manifest = None
+
+        # Check module.yaml
+        manifest_path = mod_dir / "module.yaml"
+        if not manifest_path.exists():
+            errors.append("missing module.yaml")
+        else:
+            try:
+                manifest = read_manifest(mod_dir)
+            except Exception as e:
+                errors.append(f"invalid module.yaml: {e}")
+
+            if manifest and manifest.kind not in KIND_SPECS:
+                errors.append(f"unknown kind '{manifest.kind}'")
+
+        # Check required files per kind
+        if manifest_path.exists() and manifest:
+            spec = KIND_SPECS.get(manifest.kind)
+            if spec:
+                for req_file in spec.required_files:
+                    if not (mod_dir / req_file).exists():
+                        errors.append(f"missing {req_file} (required for {manifest.kind} kind)")
+
+        # Check llms.txt links
+        llms_path = mod_dir / "llms.txt"
+        if llms_path.exists():
+            for line in llms_path.read_text().splitlines():
+                # Parse markdown links: [text](path)
+                for match in re.finditer(r'\[.*?\]\((.+?)\)', line):
+                    link_target = match.group(1)
+                    if link_target.startswith("http"):
+                        continue
+                    if not (mod_dir / link_target).exists():
+                        errors.append(f"llms.txt links to '{link_target}' which does not exist")
+
+        if errors:
+            print(f"{name}  FAIL")
+            for e in errors:
+                print(f"  - {e}")
+            all_pass = False
+        else:
+            print(f"{name}  PASS")
+
+    if not all_pass:
+        sys.exit(1)
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="eic",
+        description="Everything Is Context — module manager",
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # init
+    subparsers.add_parser("init", help="Initialize the workspace")
+
+    # new
+    new_parser = subparsers.add_parser("new", help="Scaffold a new module")
+    new_parser.add_argument("kind", choices=list(KIND_SPECS.keys()), help="Module kind")
+    new_parser.add_argument("name", help="Module name")
+
+    # load
+    load_parser = subparsers.add_parser("load", help="Load modules into workspace")
+    load_parser.add_argument("names", nargs="+", help="Module names to load")
+
+    # unload
+    unload_parser = subparsers.add_parser("unload", help="Unload a module from workspace")
+    unload_parser.add_argument("name", help="Module name to unload")
+
+    # ls
+    subparsers.add_parser("ls", help="List all modules")
+
+    # env
+    subparsers.add_parser("env", help="Check secret variable status")
+
+    # validate
+    validate_parser = subparsers.add_parser("validate", help="Validate module structure")
+    validate_parser.add_argument("name", nargs="?", help="Module name (validates all if omitted)")
+
+    args = parser.parse_args()
+    if args.command == "init":
+        cmd_init(args)
+    elif args.command == "new":
+        cmd_new(args)
+    elif args.command == "load":
+        cmd_load(args)
+    elif args.command == "unload":
+        cmd_unload(args)
+    elif args.command == "ls":
+        cmd_ls(args)
+    elif args.command == "env":
+        cmd_env(args)
+    elif args.command == "validate":
+        cmd_validate(args)
+    elif args.command is None:
+        parser.print_help()
+        sys.exit(1)
+    else:
+        print(f"Command '{args.command}' not yet implemented")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

eic/data/example/info.md

@@ -0,0 +1,30 @@
+# example
+
+## Purpose
+This is a sample module showing the structure of a context module. Use it as a reference when creating your own modules.
+
+## Where it lives
+This module exists locally in your workspace.
+
+## Auth & access
+No authentication needed — this is a documentation-only module.
+
+## Key entities
+- **Modules** — folders with a `module.yaml` and `llms.txt`
+- **Kinds** — integration, task, or workflow
+
+## Operations
+- Read this module's files to understand the structure
+- Create your own module with `eic new integration <name>`
+
+## Examples
+```bash
+# Create a new integration module
+eic new integration stripe
+
+# Load it into the workspace
+eic load stripe
+
+# Check module structure
+eic validate stripe
+```

eic/data/example/llms.txt

@@ -0,0 +1,6 @@
+# example
+
+> A sample module demonstrating the context module structure
+
+- [info.md](info.md): What this module contains and how to use it
+- [module.yaml](module.yaml): Module configuration

eic/data/example/module.yaml

@@ -0,0 +1 @@
+name: example

eic/data/secrets.md

@@ -0,0 +1,16 @@
+# Secrets
+
+Secrets are environment variables. Modules declare which variables they need in `module.yaml` under the `secrets:` list — variable names only, never values.
+
+## How it works
+
+1. Check a module's `module.yaml` for its `secrets:` list
+2. Values live in `.env` at the project root (gitignored, never committed)
+3. `.env.example` is auto-generated with all required variable names
+4. Run `eic env` to check which variables are set or missing
+
+## Rules
+
+- Never hardcode secret values in module files
+- Never commit `.env` to version control
+- Access secrets via `os.environ` in scripts

everythingiscontext-0.1.0.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: everythingiscontext
+Version: 0.1.0
+Summary: Agent-agnostic context management system
+License-Expression: MIT
+Project-URL: Homepage, https://everythingiscontext.com
+Project-URL: Repository, https://github.com/bleak-ai/everythingiscontext
+Requires-Python: >=3.11
+Requires-Dist: pydantic
+Requires-Dist: pyyaml

everythingiscontext-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+core/__init__.py,sha256=VJvE1rQXG4BRwvFK0ezbG4fv97Dd4EYgS21N5Ep4PkY,23
+core/kind_specs.py,sha256=1dqJpj1UoMwm2WtpBISkqcyjx52-BhBcPXs93RR4kmA,4603
+core/llms_gen.py,sha256=ME8a37y44E5i39Wj7axHWyn7VzyBnPQKhTh_HunylqQ,3741
+core/manifest.py,sha256=NkSW1a2cru_gV_Dy4RNsB79qPwBJBvD09ezhiEPuYQA,7839
+core/schemas.py,sha256=LxCOrAnqG49MADz42ulYJHVzIESoN9l9F4G2eZgiX8g,676
+core/templates/module_features.md,sha256=F_vc-Wd0LdImwbxscHE7BYU9eEaYEM5Rvno85obcYyY,554
+core/templates/principles.md,sha256=vTqJPiGopKTM2UFiDfIqT40_Z-c4fKz2rsnbzV40XRo,1931
+core/templates/system.md,sha256=xOpAcblWbm4_RjmQAahm0pvh4kWR6Bh7PoV8f6o1ilg,1775
+eic/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+eic/cli.py,sha256=edYtj7B7N3-lSd-HUnFtR6VnwIBwatahw9mjkqJbNaw,14805
+eic/data/secrets.md,sha256=9euH9JaUyDd7DpxYvOsNHa00kHsHipemKzrp0VDbwAg,595
+eic/data/example/info.md,sha256=zd3LJhOzWIinHh_gnoLBcgivM6m66to5jAWvLaKp3pY,725
+eic/data/example/llms.txt,sha256=MM1JRSkZqfCOSW2nOQg2osekmV9BPMKHFid2h1ixzaM,190
+eic/data/example/module.yaml,sha256=FfzDhwYlmAv1jxW6kEc2tP-hqESVqPT1HXgeIRAW50M,14
+everythingiscontext-0.1.0.dist-info/METADATA,sha256=qaTkjcXWW_LxW-7psnnjFnmTfqfniU-iAr33S8HKHhU,335
+everythingiscontext-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+everythingiscontext-0.1.0.dist-info/entry_points.txt,sha256=3aE6sudwiW6thin6LpM5vLsx7l00qIpuukmV4FPM-ds,37
+everythingiscontext-0.1.0.dist-info/top_level.txt,sha256=h0-X8BoIp5zgnMAZo8_oshowZPUwb6YTCaapXy18Bwc,9
+everythingiscontext-0.1.0.dist-info/RECORD,,

everythingiscontext-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

everythingiscontext-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+eic = eic.cli:main

everythingiscontext-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+core
+eic