projectmem 0.0.1__py3-none-any.whl

projectmem/__init__.py

@@ -0,0 +1,3 @@
+"""Local-first memory for repos."""
+
+__version__ = "0.0.1"

projectmem/cli.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import typer
+
+from projectmem.commands import attempt as attempt_command
+from projectmem.commands import decision as decision_command
+from projectmem.commands import fix as fix_command
+from projectmem.commands import init as init_command
+from projectmem.commands import log as log_command
+from projectmem.commands import note as note_command
+from projectmem.commands import regenerate as regenerate_command
+from projectmem.commands import search as search_command
+from projectmem.commands import show as show_command
+from projectmem.storage import ProjectMemError
+
+app = typer.Typer(
+    help="Local-first memory for repos.",
+    no_args_is_help=True,
+    add_completion=False,
+)
+
+
+@app.callback()
+def callback() -> None:
+    """Capture issues, attempts, fixes, decisions, and notes for this repo."""
+
+
+@app.command()
+def init() -> None:
+    """Create .projectmem/ in the current repo."""
+    init_command.run()
+
+
+@app.command()
+def log(text: str) -> None:
+    """Start a new issue."""
+    log_command.run(text)
+
+
+@app.command()
+def attempt(
+    text: str,
+    worked: bool = typer.Option(False, "--worked", help="Mark the attempt as worked."),
+    failed: bool = typer.Option(False, "--failed", help="Mark the attempt as failed."),
+    partial: bool = typer.Option(False, "--partial", help="Mark the attempt as partial."),
+) -> None:
+    """Record an attempt on the current issue."""
+    attempt_command.run(text, worked=worked, failed=failed, partial=partial)
+
+
+@app.command()
+def fix(text: str) -> None:
+    """Record a fix and close the current issue."""
+    fix_command.run(text)
+
+
+@app.command()
+def decision(text: str) -> None:
+    """Record a decision."""
+    decision_command.run(text)
+
+
+@app.command()
+def note(text: str) -> None:
+    """Record a free-form note."""
+    note_command.run(text)
+
+
+@app.command()
+def show() -> None:
+    """Print the current summary.md."""
+    show_command.run()
+
+
+@app.command()
+def search(query: str) -> None:
+    """Plain-text search across events."""
+    search_command.run(query)
+
+
+@app.command()
+def regenerate() -> None:
+    """Rebuild summary.md from events.jsonl."""
+    regenerate_command.run()
+
+
+def main() -> None:
+    try:
+        app()
+    except ProjectMemError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        raise typer.Exit(1) from exc
+
+
+if __name__ == "__main__":
+    main()

projectmem/commands/__init__.py

@@ -0,0 +1 @@
+"""Command implementations for projectmem."""

projectmem/commands/attempt.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import typer
+
+from projectmem.models import Event
+from projectmem.storage import (
+    ProjectMemError,
+    append_event,
+    current_issue_id,
+    get_git_commit,
+    read_events,
+)
+from projectmem.summary import regenerate_summary
+
+
+def run(text: str, *, worked: bool, failed: bool, partial: bool) -> None:
+    selected = [name for name, flag in [
+        ("worked", worked),
+        ("failed", failed),
+        ("partial", partial),
+    ] if flag]
+    if len(selected) > 1:
+        raise ProjectMemError("Use only one of --worked, --failed, or --partial.")
+
+    events = read_events()
+    issue_id = current_issue_id(events)
+    if issue_id is None:
+        raise ProjectMemError("No open issue found. Run `pm log <text>` first.")
+
+    outcome = selected[0] if selected else "partial"
+    append_event(
+        Event(
+            type="attempt",
+            issue_id=issue_id,
+            summary=text,
+            outcome=outcome,
+            git_commit=get_git_commit(),
+        )
+    )
+    regenerate_summary()
+    typer.echo(f"Recorded {outcome} attempt on #{issue_id}")

projectmem/commands/decision.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+import typer
+
+from projectmem.models import Event
+from projectmem.storage import append_event, get_git_commit
+from projectmem.summary import regenerate_summary
+
+
+def run(text: str) -> None:
+    append_event(Event(type="decision", summary=text, git_commit=get_git_commit()))
+    regenerate_summary()
+    typer.echo("Recorded decision")

projectmem/commands/fix.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import typer
+
+from projectmem.models import Event
+from projectmem.storage import (
+    ProjectMemError,
+    append_event,
+    current_issue_id,
+    get_git_commit,
+    read_events,
+)
+from projectmem.summary import regenerate_summary
+
+
+def run(text: str) -> None:
+    events = read_events()
+    issue_id = current_issue_id(events)
+    if issue_id is None:
+        raise ProjectMemError("No open issue found. Run `pm log <text>` first.")
+
+    append_event(
+        Event(
+            type="fix",
+            issue_id=issue_id,
+            summary=text,
+            git_commit=get_git_commit(),
+        )
+    )
+    regenerate_summary()
+    typer.echo(f"Fixed issue #{issue_id}")

projectmem/commands/init.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+import typer
+
+from projectmem.storage import initialize
+
+
+def run() -> None:
+    path = initialize()
+    typer.echo(f"Initialized {path}")

projectmem/commands/log.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import typer
+
+from projectmem.models import Event
+from projectmem.storage import append_event, get_git_commit, next_issue_id, read_events
+from projectmem.summary import regenerate_summary
+
+
+def run(text: str) -> None:
+    events = read_events()
+    issue_id = next_issue_id(events)
+    event = Event(
+        type="issue",
+        issue_id=issue_id,
+        summary=text,
+        git_commit=get_git_commit(),
+    )
+    append_event(event)
+    regenerate_summary()
+    typer.echo(f"Logged issue #{issue_id}")

projectmem/commands/note.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+import typer
+
+from projectmem.models import Event
+from projectmem.storage import append_event, get_git_commit
+from projectmem.summary import regenerate_summary
+
+
+def run(text: str) -> None:
+    append_event(Event(type="note", summary=text, git_commit=get_git_commit()))
+    regenerate_summary()
+    typer.echo("Recorded note")

projectmem/commands/regenerate.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+import typer
+
+from projectmem.summary import regenerate_summary
+
+
+def run() -> None:
+    path = regenerate_summary()
+    typer.echo(f"Regenerated {path}")

projectmem/commands/search.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+import typer
+
+from projectmem.search import search_events
+
+
+def run(query: str) -> None:
+    matches = search_events(query)
+    if not matches:
+        typer.echo("No matches.")
+        return
+
+    for event in matches:
+        issue = f" #{event.issue_id}" if event.issue_id else ""
+        outcome = f" ({event.outcome})" if event.outcome else ""
+        typer.echo(f"{event.timestamp} {event.type}{issue}{outcome}: {event.summary}")

projectmem/commands/show.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+import typer
+
+from projectmem.storage import summary_path
+
+
+def run() -> None:
+    typer.echo(summary_path().read_text(encoding="utf-8"))

projectmem/models.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from datetime import datetime, timezone
+from typing import Any
+from uuid import uuid4
+
+
+VALID_EVENT_TYPES = {
+    "issue",
+    "hypothesis",
+    "attempt",
+    "fix",
+    "decision",
+    "note",
+}
+
+VALID_OUTCOMES = {"worked", "failed", "partial"}
+
+
+def utc_now_iso() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace(
+        "+00:00", "Z"
+    )
+
+
+@dataclass
+class Event:
+    type: str
+    summary: str
+    id: str = field(default_factory=lambda: f"evt_{uuid4().hex[:20]}")
+    timestamp: str = field(default_factory=utc_now_iso)
+    issue_id: str | None = None
+    outcome: str | None = None
+    files: list[str] = field(default_factory=list)
+    command: str | None = None
+    notes: str | None = None
+    git_commit: str | None = None
+
+    def __post_init__(self) -> None:
+        if self.type not in VALID_EVENT_TYPES:
+            raise ValueError(f"Unsupported event type: {self.type}")
+        if self.outcome is not None and self.outcome not in VALID_OUTCOMES:
+            raise ValueError(f"Unsupported outcome: {self.outcome}")
+        self.summary = self.summary.strip()
+        if not self.summary:
+            raise ValueError("Event summary cannot be empty")
+
+    def to_dict(self) -> dict[str, Any]:
+        data = asdict(self)
+        return {key: value for key, value in data.items() if value not in (None, [])}
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Event":
+        return cls(
+            id=data.get("id") or f"evt_{uuid4().hex[:20]}",
+            timestamp=data.get("timestamp") or utc_now_iso(),
+            type=data["type"],
+            issue_id=data.get("issue_id"),
+            summary=data["summary"],
+            outcome=data.get("outcome"),
+            files=list(data.get("files") or []),
+            command=data.get("command"),
+            notes=data.get("notes"),
+            git_commit=data.get("git_commit"),
+        )

projectmem/search.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from projectmem.models import Event
+from projectmem.storage import read_events
+
+
+def search_events(query: str) -> list[Event]:
+    needle = query.casefold()
+    return [
+        event
+        for event in read_events()
+        if needle in event.summary.casefold()
+        or (event.notes and needle in event.notes.casefold())
+        or any(needle in file_path.casefold() for file_path in event.files)
+    ]

projectmem/storage.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+
+from projectmem.models import Event
+
+MEM_DIR = ".projectmem"
+SUMMARY_FILE = "summary.md"
+EVENTS_FILE = "events.jsonl"
+CONFIG_FILE = "config.toml"
+ISSUES_DIR = "issues"
+
+
+class ProjectMemError(RuntimeError):
+    pass
+
+
+def mem_path(root: Path | None = None) -> Path:
+    return (root or Path.cwd()) / MEM_DIR
+
+
+def require_mem_dir(root: Path | None = None) -> Path:
+    path = mem_path(root)
+    if not path.exists():
+        raise ProjectMemError("No .projectmem directory found. Run `projectmem init`.")
+    return path
+
+
+def events_path(root: Path | None = None) -> Path:
+    return require_mem_dir(root) / EVENTS_FILE
+
+
+def summary_path(root: Path | None = None) -> Path:
+    return require_mem_dir(root) / SUMMARY_FILE
+
+
+def issues_dir(root: Path | None = None) -> Path:
+    return require_mem_dir(root) / ISSUES_DIR
+
+
+def initialize(root: Path | None = None) -> Path:
+    root_path = root or Path.cwd()
+    project_dir = mem_path(root_path)
+    project_dir.mkdir(exist_ok=True)
+    (project_dir / ISSUES_DIR).mkdir(exist_ok=True)
+    (project_dir / EVENTS_FILE).touch(exist_ok=True)
+
+    config = project_dir / CONFIG_FILE
+    if not config.exists():
+        config.write_text(
+            'summary_size_limit_kb = 20\nrecent_days = 30\nproject_description = ""\n',
+            encoding="utf-8",
+        )
+
+    summary = project_dir / SUMMARY_FILE
+    if not summary.exists():
+        summary.write_text(
+            "# projectmem\n\n"
+            "_Last updated: never_\n\n"
+            "## What this project is\n"
+            "Not described yet.\n",
+            encoding="utf-8",
+        )
+
+    ensure_gitignore_entry(root_path)
+    return project_dir
+
+
+def ensure_gitignore_entry(root: Path) -> None:
+    gitignore = root / ".gitignore"
+    entry = f"{MEM_DIR}/{EVENTS_FILE}"
+    if gitignore.exists():
+        lines = gitignore.read_text(encoding="utf-8").splitlines()
+        if entry in lines:
+            return
+        prefix = "" if not lines or lines[-1] == "" else "\n"
+        gitignore.write_text(
+            gitignore.read_text(encoding="utf-8") + f"{prefix}{entry}\n",
+            encoding="utf-8",
+        )
+    else:
+        gitignore.write_text(f"{entry}\n", encoding="utf-8")
+
+
+def read_events(root: Path | None = None) -> list[Event]:
+    path = events_path(root)
+    events: list[Event] = []
+    for line_number, line in enumerate(path.read_text(encoding="utf-8").splitlines(), 1):
+        if not line.strip():
+            continue
+        try:
+            events.append(Event.from_dict(json.loads(line)))
+        except (json.JSONDecodeError, KeyError, ValueError) as exc:
+            raise ProjectMemError(f"Invalid event at {path}:{line_number}: {exc}") from exc
+    return events
+
+
+def append_event(event: Event, root: Path | None = None) -> Event:
+    path = events_path(root)
+    with path.open("a", encoding="utf-8") as handle:
+        handle.write(json.dumps(event.to_dict(), sort_keys=True) + "\n")
+    return event
+
+
+def next_issue_id(events: list[Event]) -> str:
+    issue_ids = [
+        int(event.issue_id)
+        for event in events
+        if event.type == "issue" and event.issue_id and event.issue_id.isdigit()
+    ]
+    return f"{(max(issue_ids) if issue_ids else 0) + 1:04d}"
+
+
+def current_issue_id(events: list[Event]) -> str | None:
+    closed = {event.issue_id for event in events if event.type == "fix" and event.issue_id}
+    for event in reversed(events):
+        if event.type == "issue" and event.issue_id not in closed:
+            return event.issue_id
+    return None
+
+
+def get_git_commit(root: Path | None = None) -> str | None:
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--short", "HEAD"],
+            cwd=root or Path.cwd(),
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    except (OSError, subprocess.CalledProcessError):
+        return None
+    commit = result.stdout.strip()
+    return commit or None

projectmem/summary.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+import re
+from collections import defaultdict
+from datetime import datetime, timezone
+from pathlib import Path
+
+from projectmem.models import Event
+from projectmem.storage import issues_dir, read_events, summary_path
+
+
+def regenerate_summary(root: Path | None = None) -> Path:
+    events = read_events(root)
+    content = build_summary(events, root or Path.cwd())
+    path = summary_path(root)
+    path.write_text(content, encoding="utf-8")
+    write_issue_files(events, root)
+    return path
+
+
+def build_summary(events: list[Event], root: Path) -> str:
+    project_name = root.name
+    now = datetime.now(timezone.utc).date().isoformat()
+    issues = group_issue_events(events)
+    decisions = [event for event in events if event.type == "decision"]
+    notes = [event for event in events if event.type == "note"]
+
+    lines = [
+        f"# projectmem — {project_name}",
+        "",
+        f"_Last updated: {now}_",
+        "",
+        "## What this project is",
+        "Not described yet.",
+        "",
+        "## Recent issues",
+    ]
+
+    if not issues:
+        lines.append("- No issues logged yet.")
+    else:
+        for issue_id, issue_events in sorted(issues.items(), reverse=True):
+            issue = next(event for event in issue_events if event.type == "issue")
+            fix = next((event for event in reversed(issue_events) if event.type == "fix"), None)
+            status = "fixed" if fix else "open"
+            marker = "DONE" if fix else "OPEN"
+            outcome = f" -> {fix.summary}" if fix else ""
+            lines.append(f"- [{marker}] #{issue_id} {issue.summary}{outcome} ({status})")
+            lessons = [
+                event.summary
+                for event in issue_events
+                if event.type == "attempt" and event.outcome == "failed"
+            ]
+            for lesson in lessons[-2:]:
+                lines.append(f"  - Failed attempt: {lesson}")
+
+    lines.extend(["", "## Decisions"])
+    if decisions:
+        for event in decisions:
+            lines.append(f"- {event.summary}")
+    else:
+        lines.append("- No decisions logged yet.")
+
+    lines.extend(["", "## Notes"])
+    if notes:
+        for event in notes[-10:]:
+            lines.append(f"- {event.summary}")
+    else:
+        lines.append("- No notes logged yet.")
+
+    lines.extend(["", "## Key files"])
+    key_files = collect_files(events)
+    if key_files:
+        for file_path in key_files[:20]:
+            lines.append(f"- `{file_path}`")
+    else:
+        lines.append("- No key files logged yet.")
+
+    lines.extend(["", "## Open questions"])
+    lines.append("- None logged yet.")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def group_issue_events(events: list[Event]) -> dict[str, list[Event]]:
+    issues: dict[str, list[Event]] = defaultdict(list)
+    for event in events:
+        if event.issue_id:
+            issues[event.issue_id].append(event)
+    return dict(issues)
+
+
+def collect_files(events: list[Event]) -> list[str]:
+    seen: set[str] = set()
+    files: list[str] = []
+    for event in events:
+        for explicit in event.files:
+            if explicit not in seen:
+                seen.add(explicit)
+                files.append(explicit)
+        for inferred in infer_file_mentions(event.summary):
+            if inferred not in seen:
+                seen.add(inferred)
+                files.append(inferred)
+    return files
+
+
+def infer_file_mentions(text: str) -> list[str]:
+    pattern = r"(?<![\w/.-])[\w./-]+\.[A-Za-z0-9]+(?::\d+)?"
+    return re.findall(pattern, text)
+
+
+def write_issue_files(events: list[Event], root: Path | None = None) -> None:
+    for issue_id, issue_events in group_issue_events(events).items():
+        issue = next((event for event in issue_events if event.type == "issue"), None)
+        if issue is None:
+            continue
+        slug = slugify(issue.summary)
+        path = issues_dir(root) / f"{issue_id}-{slug}.md"
+        lines = [f"# #{issue_id} {issue.summary}", ""]
+        for event in issue_events:
+            detail = f"- {event.timestamp} `{event.type}`: {event.summary}"
+            if event.outcome:
+                detail += f" ({event.outcome})"
+            lines.append(detail)
+        lines.append("")
+        path.write_text("\n".join(lines), encoding="utf-8")
+
+
+def slugify(text: str) -> str:
+    slug = re.sub(r"[^a-z0-9]+", "-", text.lower()).strip("-")
+    return (slug or "issue")[:48].strip("-") or "issue"

projectmem-0.0.1.dist-info/METADATA

@@ -0,0 +1,212 @@
+Metadata-Version: 2.3
+Name: projectmem
+Version: 0.0.1
+Summary: Project memory for humans and AI tools: capture issues, attempts, fixes, and decisions in readable Markdown and JSONL.
+Project-URL: Homepage, https://github.com/riponcm/projectmem
+Project-URL: Repository, https://github.com/riponcm/projectmem
+Project-URL: Issues, https://github.com/riponcm/projectmem/issues
+Author: Ripon Chandra Malo
+License: MIT
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Documentation
+Requires-Python: >=3.10
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# projectmem
+
+`projectmem` gives your projects a readable memory.
+
+It records the development story that usually disappears between commits:
+issues, failed attempts, working fixes, decisions, notes, and the files involved.
+The result is a small `.projectmem/` folder that both humans and AI tools can
+read without a vendor-specific integration.
+
+Git shows what changed. `projectmem` helps explain what happened, what was
+tried, what failed, and why the current solution exists.
+
+## Why It Exists
+
+Project context is expensive to rebuild.
+
+When you return to a codebase after days or weeks, you often need to rediscover
+why something was implemented a certain way. AI coding tools have the same
+problem: every new session may scan files, infer history, and repeat analysis
+that was already done before.
+
+`projectmem` is designed to reduce that repeated work. Instead of asking a
+person or an AI assistant to reconstruct the full project story from source
+files alone, it keeps a compact, structured memory in Markdown and JSONL.
+
+For AI-assisted development, the intended pattern is simple:
+
+- read `.projectmem/summary.md` first
+- open detailed issue files only when needed
+- avoid repeating failed approaches that were already recorded
+- spend more context window on the current task instead of rediscovering old
+  decisions
+
+The exact token savings depend on the project and workflow, but the goal is to
+replace repeated broad scans of tens or hundreds of kilobytes with a concise
+summary targeted to stay under roughly 20 KB. In practical AI workflows, that
+can save a significant percentage of context tokens across repeated sessions,
+especially on long-lived projects.
+
+## What It Captures
+
+`projectmem` is intentionally narrow. It is a project logbook for development
+knowledge that does not fit cleanly into commits.
+
+It captures:
+
+- issues you are investigating
+- hypotheses and attempts
+- whether an attempt worked, failed, or partially helped
+- final fixes
+- architectural or implementation decisions
+- notes and gotchas
+- file references that matter to the story
+
+It does not replace Git, issue trackers, documentation, code search, or AI
+memory systems. It complements them by preserving the reasoning and failed paths
+around a project.
+
+## Installation
+
+```bash
+pip install projectmem
+```
+
+This installs two commands:
+
+```bash
+projectmem
+pm
+```
+
+Both commands run the same CLI. `projectmem` is the canonical command; `pm` is a
+short alias for daily use.
+
+## Quick Start
+
+Initialize memory inside a project:
+
+```bash
+cd path/to/your-project
+projectmem init
+```
+
+Record the story as you work:
+
+```bash
+pm log "auth tokens expire after 1h instead of 24h"
+pm attempt "bumped JWT_EXPIRY in config.py" --failed
+pm attempt "found hardcoded TTL in middleware" --worked
+pm fix "changed TOKEN_TTL in auth/middleware.py:42"
+pm decision "keep auth middleware stateless so workers can scale horizontally"
+pm note "local test suite requires the test database to be running"
+```
+
+Read the current project memory:
+
+```bash
+pm show
+```
+
+Search previous entries:
+
+```bash
+pm search token
+```
+
+Regenerate the summary from the raw event log:
+
+```bash
+pm regenerate
+```
+
+## Project Memory Files
+
+`projectmem init` creates:
+
+```text
+.projectmem/
+├── summary.md
+├── events.jsonl
+├── issues/
+└── config.toml
+```
+
+File roles:
+
+- `.projectmem/summary.md` is the compact memory for humans and AI tools.
+- `.projectmem/events.jsonl` is the append-only raw event log.
+- `.projectmem/issues/` contains per-issue Markdown files for deeper context.
+- `.projectmem/config.toml` stores project-specific settings.
+
+By default, `projectmem init` adds `.projectmem/events.jsonl` to `.gitignore`.
+The raw log can contain noisy or sensitive working notes. The generated summary,
+issue files, and config are the parts most teams may choose to commit.
+
+## Commands
+
+| Command | Purpose |
+|---|---|
+| `projectmem init` | Create `.projectmem/` in the current project |
+| `pm log <text>` | Start a new issue |
+| `pm attempt <text> --worked` | Record a successful attempt |
+| `pm attempt <text> --failed` | Record a failed attempt |
+| `pm attempt <text> --partial` | Record a partially useful attempt |
+| `pm fix <text>` | Record the fix for the current issue |
+| `pm decision <text>` | Record a project decision |
+| `pm note <text>` | Record a free-form note |
+| `pm show` | Print `.projectmem/summary.md` |
+| `pm search <query>` | Search recorded events |
+| `pm regenerate` | Rebuild the summary from `events.jsonl` |
+
+## AI Workflow
+
+Any AI assistant can use `projectmem` without a plugin.
+
+At the start of a session, ask the assistant to read:
+
+```text
+.projectmem/summary.md
+```
+
+That file is designed to provide the current project story: recent issues,
+outcomes, known gotchas, decisions, and key files. If more detail is needed, the
+assistant can open the relevant file under `.projectmem/issues/`.
+
+This keeps the memory portable across tools such as Claude Code, Cursor, Codex,
+custom agents, and plain terminal workflows. The storage is ordinary Markdown
+and JSONL.
+
+## Design Principles
+
+- Local-first: no network calls, no cloud service, no telemetry.
+- Human-readable: Markdown and JSONL only.
+- AI-tool-agnostic: no dependency on one assistant or editor.
+- Append-only raw log: the original event history remains available.
+- Compact derived summary: the main AI-readable file stays small.
+- Small CLI surface: a few commands focused on daily development memory.
+
+## Development Status
+
+`projectmem` is in early development. Version `0.0.1` is the initial package
+release for testing and name reservation. The first stable public workflow will
+come after real use across several projects.
+
+## License
+
+MIT

projectmem-0.0.1.dist-info/RECORD

@@ -0,0 +1,21 @@
+projectmem/__init__.py,sha256=RnLA1Mg1dOdpW8_p9hfvIiMtsuOmelWBTn5hAHrmE-8,59
+projectmem/cli.py,sha256=dan4mJvyuGUPjUsnzjBOv5KlxqLKa3VX-eYyS355OHE,2384
+projectmem/models.py,sha256=wNrwqWgP7VkX-tc6UjAWKFja_rZp-uGNGeIte_G-W9E,2005
+projectmem/search.py,sha256=LDJJwOmMUWF0TRsw4SQ9qIm2xbqFVe0yR1-rhut38mc,445
+projectmem/storage.py,sha256=VdthSF56TRDY1F80oQlfLD51uorSodHgsMz2tyjvAxM,4035
+projectmem/summary.py,sha256=qDFnhlGM2F37120MsHSmV7OY1n9ie0HLrhEGM2WRF4c,4468
+projectmem/commands/__init__.py,sha256=xXtvqrB6FKi-acrLa9NAyzUwYkxT_y-Yq9qh7yg7qek,46
+projectmem/commands/attempt.py,sha256=k0Fz98w7rigPfqVrmU3BdIjLsG5E13J5YtbCSfvfcJ4,1114
+projectmem/commands/decision.py,sha256=c5EowWN6LJXwF6E9FlaKjn9l0OB8LVW1ruKYvPO3lu4,371
+projectmem/commands/fix.py,sha256=EejsZJfSa8mPAb3tpGnIkNmyqkLpkbNo5NFXBH7AsxM,712
+projectmem/commands/init.py,sha256=g2iqOwPEDxcup9JfeHNvkq7BRaxiPYCYfcoaGh1cZ7M,175
+projectmem/commands/log.py,sha256=dxnbN8y10PohFdkAUpHwY_snMn5DyKjysjbxELdsDKw,544
+projectmem/commands/note.py,sha256=xMbO5GjCVyaW3BRR-EVR78S6I0EOeFQyRmYgSk70GPA,363
+projectmem/commands/regenerate.py,sha256=-Q9MK15o85eGD-Icxz8nj2Mc5Uem6gH0mmdCEjT7DUg,191
+projectmem/commands/search.py,sha256=5Kuf-pmtVNnlxCr_oShfbVOywTqkRifomfLNuIg6Kl0,472
+projectmem/commands/show.py,sha256=xXNHms6MauAAA74QwfVeZX5iYCKjPl78T_wTXpUuznE,174
+projectmem-0.0.1.dist-info/METADATA,sha256=gyHO36TtCC_togD2SAAycicacKXPFDQsck5lkBMbLh8,6757
+projectmem-0.0.1.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+projectmem-0.0.1.dist-info/entry_points.txt,sha256=olP4t3SzkwaCNpDqhe5OUzHxEOs6fqcbNEJWXQiVwlo,76
+projectmem-0.0.1.dist-info/licenses/LICENSE,sha256=si3wH1MtIlq7k3Eh1RyOfLKuV_pJjupeLrmAHM2_QXM,1080
+projectmem-0.0.1.dist-info/RECORD,,

projectmem-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.26.3
+Root-Is-Purelib: true
+Tag: py3-none-any

projectmem-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+pm = projectmem.cli:main
+projectmem = projectmem.cli:main

projectmem-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 projectmem contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.