agent-notes 2.20.0__tar.gz → 2.21.0__tar.gz

{agent_notes-2.20.0 → agent_notes-2.21.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-notes
-Version: 2.20.0
+Version: 2.21.0
 Summary: AI agent configuration manager for Claude Code, OpenCode, and Copilot
 Author-email: Eugene Naumov <min.verkligheten@gmail.com>
 License-Expression: MIT

agent_notes-2.21.0/agent_notes/VERSION

@@ -0,0 +1 @@
+2.21.0

{agent_notes-2.20.0 → agent_notes-2.21.0}/agent_notes/cli.py

@@ -273,7 +273,7 @@ def main():
     # memory
     p_memory = subparsers.add_parser("memory", help="Manage agent memory")
     p_memory.add_argument("action", nargs="?", default="list",
-        choices=["init", "list", "vault", "index", "add", "size", "show", "reset", "export", "import", "ingest", "query", "lint"],
+        choices=["init", "list", "vault", "index", "add", "size", "show", "reset", "export", "import", "ingest", "ingest-file", "ingest-url", "ingest-folder", "query", "lint"],
         help="Memory action")
     p_memory.add_argument("name", nargs="?", help="Agent name / note title (for show/reset/add)")
     p_memory.add_argument("extra", nargs="*", help="Additional args (for add: body [type] [agent] [project])")

{agent_notes-2.20.0 → agent_notes-2.21.0}/agent_notes/commands/memory.py

@@ -508,6 +508,102 @@ def do_ingest(title: str, body: str, concepts: Optional[list] = None, entities:
         print(f"  entity:  {p}")
 
 
+def do_ingest_file(file_path: str, title: str = "", body: str = "",
+                   concepts: Optional[list] = None, entities: Optional[list] = None,
+                   tags: Optional[list] = None) -> None:
+    """Ingest a local file into the wiki backend."""
+    backend, path = _load_memory_config()
+    if backend != "wiki":
+        print("The `ingest-file` subcommand is only available for the wiki backend.")
+        return
+    if path is None:
+        print("Memory path not configured.")
+        return
+    fp = Path(file_path)
+    if not fp.exists():
+        print(f"Error: file not found: {file_path}")
+        exit(1)
+    from ..services.wiki_backend import wiki_ingest_file
+    result = wiki_ingest_file(
+        path,
+        file_path=fp,
+        title=title,
+        body=body,
+        concepts=concepts or [],
+        entities=entities or [],
+        tags=tags or [],
+    )
+    _print_ingest_result(result)
+
+
+def do_ingest_url(url: str, title: str = "", body: str = "",
+                  concepts: Optional[list] = None, entities: Optional[list] = None,
+                  tags: Optional[list] = None) -> None:
+    """Ingest a URL into the wiki backend."""
+    backend, path = _load_memory_config()
+    if backend != "wiki":
+        print("The `ingest-url` subcommand is only available for the wiki backend.")
+        return
+    if path is None:
+        print("Memory path not configured.")
+        return
+    from ..services.wiki_backend import wiki_ingest_url
+    result = wiki_ingest_url(
+        path,
+        url=url,
+        title=title,
+        body=body,
+        concepts=concepts or [],
+        entities=entities or [],
+        tags=tags or [],
+    )
+    _print_ingest_result(result)
+
+
+def do_ingest_folder(folder_path: str, title: str = "", body: str = "",
+                     concepts: Optional[list] = None, entities: Optional[list] = None,
+                     tags: Optional[list] = None) -> None:
+    """Ingest a local folder into the wiki backend."""
+    backend, path = _load_memory_config()
+    if backend != "wiki":
+        print("The `ingest-folder` subcommand is only available for the wiki backend.")
+        return
+    if path is None:
+        print("Memory path not configured.")
+        return
+    fp = Path(folder_path)
+    if not fp.exists():
+        print(f"Error: folder not found: {folder_path}")
+        exit(1)
+    from ..services.wiki_backend import wiki_ingest_folder
+    result = wiki_ingest_folder(
+        path,
+        folder_path=fp,
+        title=title,
+        body=body,
+        concepts=concepts or [],
+        entities=entities or [],
+        tags=tags or [],
+    )
+    _print_ingest_result(result)
+
+
+def _print_ingest_result(result: dict) -> None:
+    source_paths = result.get("source", [])
+    concept_paths = result.get("concepts", [])
+    entity_paths = result.get("entities", [])
+    title = ""
+    if source_paths:
+        title = source_paths[0].stem.replace("-", " ").title()
+    print(f"{Color.GREEN}Ingested: {title}{Color.NC}")
+    for p in source_paths:
+        print(f"  source:  {p}")
+    for p in concept_paths:
+        print(f"  concept: {p}")
+    for p in entity_paths:
+        print(f"  entity:  {p}")
+
+
 def do_query(keyword: str) -> None:
     """Search wiki pages by keyword."""
     backend, path = _load_memory_config()
@@ -796,6 +892,42 @@ def memory(action: str = "list", name: Optional[str] = None, extra: Optional[lis
         entities = [e.strip() for e in entities_csv.split(",") if e.strip()] if entities_csv else None
         tags = [t.strip() for t in tags_csv.split(",") if t.strip()] if tags_csv else None
         do_ingest(name, body, concepts=concepts, entities=entities, tags=tags)
+    elif action == "ingest-file":
+        if not name:
+            print("Error: ingest-file requires a file path.")
+            exit(1)
+        body = extra[0] if extra else ""
+        concepts_csv = extra[1] if extra and len(extra) > 1 else ""
+        entities_csv = extra[2] if extra and len(extra) > 2 else ""
+        tags_csv = extra[3] if extra and len(extra) > 3 else ""
+        concepts = [c.strip() for c in concepts_csv.split(",") if c.strip()] if concepts_csv else None
+        entities = [e.strip() for e in entities_csv.split(",") if e.strip()] if entities_csv else None
+        tags = [t.strip() for t in tags_csv.split(",") if t.strip()] if tags_csv else None
+        do_ingest_file(name, body=body, concepts=concepts, entities=entities, tags=tags)
+    elif action == "ingest-url":
+        if not name:
+            print("Error: ingest-url requires a URL.")
+            exit(1)
+        body = extra[0] if extra else ""
+        concepts_csv = extra[1] if extra and len(extra) > 1 else ""
+        entities_csv = extra[2] if extra and len(extra) > 2 else ""
+        tags_csv = extra[3] if extra and len(extra) > 3 else ""
+        concepts = [c.strip() for c in concepts_csv.split(",") if c.strip()] if concepts_csv else None
+        entities = [e.strip() for e in entities_csv.split(",") if e.strip()] if entities_csv else None
+        tags = [t.strip() for t in tags_csv.split(",") if t.strip()] if tags_csv else None
+        do_ingest_url(name, body=body, concepts=concepts, entities=entities, tags=tags)
+    elif action == "ingest-folder":
+        if not name:
+            print("Error: ingest-folder requires a folder path.")
+            exit(1)
+        body = extra[0] if extra else ""
+        concepts_csv = extra[1] if extra and len(extra) > 1 else ""
+        entities_csv = extra[2] if extra and len(extra) > 2 else ""
+        tags_csv = extra[3] if extra and len(extra) > 3 else ""
+        concepts = [c.strip() for c in concepts_csv.split(",") if c.strip()] if concepts_csv else None
+        entities = [e.strip() for e in entities_csv.split(",") if e.strip()] if entities_csv else None
+        tags = [t.strip() for t in tags_csv.split(",") if t.strip()] if tags_csv else None
+        do_ingest_folder(name, body=body, concepts=concepts, entities=entities, tags=tags)
     elif action == "query":
         if not name:
             print("Error: query requires a keyword.")

agent_notes-2.21.0/agent_notes/data/skills/ingest/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: ingest
+description: "Ingest a URL, local file, or folder into the wiki brain. Fetches content, extracts concepts and entities with AI analysis, and stores in the wiki. Use when user says 'ingest', provides a URL to study, or wants to add external knowledge."
+group: memory
+---
+
+# Ingest
+
+Ingest external sources into the wiki brain for persistent, queryable knowledge.
+
+## Usage
+
+The user provides one of:
+- A **URL** (starts with `http://` or `https://`)
+- A **file path** (path to a single file)
+- A **folder path** (path to a directory)
+
+## Workflow
+
+### Step 1 — Fetch the source
+
+| Source type | How to read |
+|---|---|
+| URL | Use `WebFetch` tool to retrieve the page content |
+| File | Use `Read` tool to read the file |
+| Folder | Use `Bash` to list files (`find <path> -type f`), then `Read` key files. Skip: `__pycache__`, `.git`, `node_modules`, `.venv`, `dist`, `build`, `.egg-info` |
+
+### Step 2 — AI analysis
+
+Analyze the content and extract:
+
+1. **Title** — a concise, descriptive name for this source
+2. **Summary** — 2-5 sentence overview of what this source contains and why it matters
+3. **Concepts** — key ideas, patterns, techniques, or abstractions (e.g., "dependency injection", "event sourcing", "fan-out pattern")
+4. **Entities** — specific named things: tools, libraries, people, projects, APIs (e.g., "PostgreSQL", "Karpathy", "wiki_backend.py")
+5. **Tags** — categorization labels (e.g., "python", "architecture", "api")
+
+### Step 3 — Ingest via CLI
+
+Call the appropriate command:
+
+**For a URL:**
+```bash
+agent-notes memory ingest-url "<url>" "<summary>" "<concepts_csv>" "<entities_csv>" "<tags_csv>"
+```
+
+**For a file:**
+```bash
+agent-notes memory ingest-file "<file_path>" "<summary>" "<concepts_csv>" "<entities_csv>" "<tags_csv>"
+```
+
+**For a folder:**
+```bash
+agent-notes memory ingest-folder "<folder_path>" "<summary>" "<concepts_csv>" "<entities_csv>" "<tags_csv>"
+```
+
+The CLI archives the raw content and creates the wiki source page. The AI-extracted concepts and entities are fanned out into their own wiki pages with cross-references.
+
+### Step 4 — Report
+
+After ingestion, report to the user:
+- What was ingested (title, source type)
+- Key concepts and entities extracted
+- Number of wiki pages created/updated
+
+## Example
+
+User: `/ingest https://karpathy.github.io/2023/01/20/llm-wiki/`
+
+1. Fetch URL with WebFetch
+2. Analyze: Title="LLM Wiki by Karpathy", Summary="Proposes using LLMs to maintain personal knowledge wikis...", Concepts=["LLM Wiki", "knowledge management", "fan-out pattern"], Entities=["Andrej Karpathy"], Tags=["ai", "knowledge-management"]
+3. Run: `agent-notes memory ingest-url "https://karpathy.github.io/2023/01/20/llm-wiki/" "Proposes using LLMs to maintain personal knowledge wikis..." "LLM Wiki,knowledge management,fan-out pattern" "Andrej Karpathy" "ai,knowledge-management"`
+4. Report results

{agent_notes-2.20.0 → agent_notes-2.21.0}/agent_notes/services/wiki_backend.py

@@ -215,6 +215,196 @@ def wiki_ingest(
     return result
 
 
+# ── Ingest from file ──────────────────────────────────────────────────────────
+
+def wiki_ingest_file(
+    wiki_root: Path,
+    *,
+    file_path: Path,
+    title: str = "",
+    body: str = "",
+    concepts: list[str] | None = None,
+    entities: list[str] | None = None,
+    tags: list[str] | None = None,
+) -> dict[str, list[Path]]:
+    """Ingest a local file into the wiki. Reads content, derives title, delegates to wiki_ingest."""
+    if not file_path.is_file():
+        raise FileNotFoundError(f"File not found: {file_path}")
+    raw_content = file_path.read_text(errors="replace")
+    if not title:
+        title = file_path.stem.replace("-", " ").replace("_", " ").title()
+    if not body:
+        body = f"Ingested from local file: {file_path}"
+    return wiki_ingest(
+        wiki_root,
+        title=title,
+        body=body,
+        raw_content=raw_content,
+        raw_filename=file_path.name,
+        concepts=concepts,
+        entities=entities,
+        tags=tags,
+    )
+
+
+# ── Ingest from folder ────────────────────────────────────────────────────────
+
+_SKIP_DIRS = {"__pycache__", ".git", "node_modules", ".venv", "dist", "build"}
+_DEFAULT_EXTENSIONS = {".py", ".md", ".yaml", ".yml", ".toml", ".json", ".txt", ".rs", ".ts", ".js", ".rb", ".go", ".java"}
+
+
+def _parse_gitignore_patterns(gitignore_path: Path) -> list[str]:
+    """Return non-empty, non-comment patterns from a .gitignore file."""
+    patterns = []
+    for line in gitignore_path.read_text(errors="replace").splitlines():
+        line = line.rstrip()
+        if line and not line.startswith("#"):
+            patterns.append(line)
+    return patterns
+
+
+def _matches_gitignore(rel_path: str, patterns: list[str]) -> bool:
+    """Return True if rel_path matches any gitignore pattern (simplified fnmatch)."""
+    import fnmatch
+    parts = rel_path.replace("\\", "/").split("/")
+    name = parts[-1]
+    for pattern in patterns:
+        # Strip leading slash for anchored patterns — treat as simple fnmatch
+        clean = pattern.lstrip("/")
+        if not clean:
+            continue
+        if fnmatch.fnmatch(name, clean):
+            return True
+        if fnmatch.fnmatch(rel_path, clean):
+            return True
+        if fnmatch.fnmatch(rel_path, f"**/{clean}"):
+            return True
+    return False
+
+
+def wiki_ingest_folder(
+    wiki_root: Path,
+    *,
+    folder_path: Path,
+    title: str = "",
+    body: str = "",
+    concepts: list[str] | None = None,
+    entities: list[str] | None = None,
+    tags: list[str] | None = None,
+    extensions: list[str] | None = None,
+    respect_gitignore: bool = True,
+) -> dict[str, list[Path]]:
+    """Ingest a local folder recursively into the wiki. Concatenates file contents."""
+    if not folder_path.is_dir():
+        raise FileNotFoundError(f"Folder not found: {folder_path}")
+    allowed_exts = set(extensions) if extensions is not None else _DEFAULT_EXTENSIONS
+
+    gitignore_patterns: list[str] = []
+    if respect_gitignore:
+        gitignore_path = folder_path / ".gitignore"
+        if gitignore_path.exists():
+            gitignore_patterns = _parse_gitignore_patterns(gitignore_path)
+
+    parts: list[str] = []
+    file_count = 0
+
+    for file in sorted(folder_path.rglob("*")):
+        if not file.is_file():
+            continue
+        # Skip junk directories
+        if any(skip in file.parts for skip in _SKIP_DIRS):
+            continue
+        # Skip files with egg-info in path
+        if any(part.endswith(".egg-info") for part in file.parts):
+            continue
+        # Extension filter
+        if file.suffix not in allowed_exts:
+            continue
+        # Gitignore filter
+        rel = str(file.relative_to(folder_path))
+        if gitignore_patterns and _matches_gitignore(rel, gitignore_patterns):
+            continue
+
+        try:
+            content = file.read_text(errors="replace")
+        except OSError:
+            continue
+
+        parts.append(f"\n\n--- FILE: {rel} ---\n\n{content}\n")
+        file_count += 1
+
+    raw_content = "".join(parts).lstrip("\n")
+
+    if not title:
+        title = folder_path.name.replace("-", " ").replace("_", " ").title()
+    if not body:
+        body = f"Ingested from local folder: {folder_path} ({file_count} files)"
+
+    raw_filename = f"{_slug(title)}-folder.md"
+
+    return wiki_ingest(
+        wiki_root,
+        title=title,
+        body=body,
+        raw_content=raw_content,
+        raw_filename=raw_filename,
+        concepts=concepts,
+        entities=entities,
+        tags=tags,
+    )
+
+
+# ── Ingest from URL ───────────────────────────────────────────────────────────
+
+def wiki_ingest_url(
+    wiki_root: Path,
+    *,
+    url: str,
+    title: str = "",
+    body: str = "",
+    concepts: list[str] | None = None,
+    entities: list[str] | None = None,
+    tags: list[str] | None = None,
+) -> dict[str, list[Path]]:
+    """Fetch a URL and ingest its content into the wiki."""
+    import urllib.request
+    import urllib.error
+    from urllib.parse import urlparse
+
+    with urllib.request.urlopen(url) as response:
+        raw_bytes = response.read()
+    try:
+        raw_content = raw_bytes.decode("utf-8")
+    except UnicodeDecodeError:
+        raw_content = raw_bytes.decode("latin-1")
+
+    if not title:
+        m = re.search(r"<title[^>]*>([^<]+)</title>", raw_content, re.IGNORECASE)
+        if m:
+            title = m.group(1).strip()
+        else:
+            parsed = urlparse(url)
+            title = (parsed.hostname or "") + (parsed.path.rstrip("/") or "")
+
+    if not body:
+        body = f"Ingested from URL: {url}"
+
+    parsed = urlparse(url)
+    url_slug = _slug((parsed.hostname or "") + "-" + parsed.path.strip("/").replace("/", "-"))
+    raw_filename = f"{url_slug}.html"
+
+    return wiki_ingest(
+        wiki_root,
+        title=title,
+        body=body,
+        raw_content=raw_content,
+        raw_filename=raw_filename,
+        concepts=concepts,
+        entities=entities,
+        tags=tags,
+    )
+
+
 # ── Query ─────────────────────────────────────────────────────────────────────
 
 def wiki_query(wiki_root: Path, keyword: str) -> list[dict]:

{agent_notes-2.20.0 → agent_notes-2.21.0}/agent_notes.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-notes
-Version: 2.20.0
+Version: 2.21.0
 Summary: AI agent configuration manager for Claude Code, OpenCode, and Copilot
 Author-email: Eugene Naumov <min.verkligheten@gmail.com>
 License-Expression: MIT

{agent_notes-2.20.0 → agent_notes-2.21.0}/agent_notes.egg-info/SOURCES.txt

@@ -96,6 +96,7 @@ agent_notes/data/skills/git/SKILL.md
 agent_notes/data/skills/grill-me/SKILL.md
 agent_notes/data/skills/grill-with-docs/SKILL.md
 agent_notes/data/skills/improve-codebase-architecture/SKILL.md
+agent_notes/data/skills/ingest/SKILL.md
 agent_notes/data/skills/obsidian-memory/SKILL.md
 agent_notes/data/skills/rails/SKILL.md
 agent_notes/data/skills/rails/controllers.md