Upload 4 files

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+manuals.json filter=lfs diff=lfs merge=lfs -text

main.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python3
+"""
+collect_manuals.py - Gather all available man pages as a JSON dataset.
+NixOS compatible; relies on `manpath` and `man`.
+"""
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+# ----------------------------------------------------------------------
+# 1. Get the man page search paths
+# ----------------------------------------------------------------------
+def get_manpaths():
+    """Return a list of directories that `man` searches for pages."""
+    # On NixOS, `manpath` prints the effective MANPATH, including all profile
+    # and store paths. Fall back to environment variable or hard-coded defaults.
+    try:
+        result = subprocess.run(["manpath", "-q"], capture_output=True, text=True, check=True)
+        paths = result.stdout.strip().split(":")
+        if paths and paths != [""]:
+            return paths
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        pass
+
+    # Fallback: parse MANPATH environment variable
+    manpath_env = os.environ.get("MANPATH")
+    if manpath_env:
+        return manpath_env.split(":")
+
+    # Standard Linux defaults
+    return ["/usr/share/man", "/usr/local/share/man"]
+
+# ----------------------------------------------------------------------
+# 2. Find all man page files
+# ----------------------------------------------------------------------
+def find_man_files(manpaths):
+    """
+    Walk each manpath directory, look inside 'man<section>' subdirs,
+    and collect (topic_name, section, full_path).
+    """
+    # Valid extensions: compressed and raw roff
+    ext_list = {".gz", ".bz2", ".xz", ".Z", ".lzma"}
+    # Also accept files without compression suffix (e.g., "man1/bash.1")
+    entries = []
+
+    for base_dir in manpaths:
+        base = Path(base_dir)
+        if not base.is_dir():
+            continue
+        # All man page directories are named man1, man2, man3, manX...
+        for man_dir in base.glob("man*"):
+            if not man_dir.is_dir():
+                continue
+            # Extract section from directory name (e.g., "man1" -> "1")
+            section = man_dir.name[3:]  # strip "man"
+            # Find all files inside (excluding symlinks that point outside)
+            for file_path in man_dir.iterdir():
+                if not file_path.is_file():
+                    continue
+                # Resolve symlinks to avoid duplicates from different paths
+                real_path = file_path.resolve()
+                # Determine name by stripping the extension(s)
+                name = file_path.name
+                # Remove known compression extensions
+                while True:
+                    stem, ext = os.path.splitext(name)
+                    if ext.lower() in ext_list:
+                        name = stem
+                    else:
+                        break
+                # Remove the section suffix if present (e.g., "open.2" -> "open")
+                # The section suffix matches the directory section, but we remove it.
+                if name.endswith(f".{section}"):
+                    name = name[: -(len(section) + 1)]
+                # Skip directories, etc.
+                if not name:
+                    continue
+                entries.append((name, section, real_path))
+    return entries
+
+# ----------------------------------------------------------------------
+# 3. Render a man page to plain text using `man -P cat`
+# ----------------------------------------------------------------------
+def render_man(topic, section, timeout=5):
+    """
+    Run `man -P cat <section> <topic>` and return its stdout as a string.
+    Returns None on failure.
+    """
+    cmd = ["man", "-P", "cat", section, topic]
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            # Some systems still pipe through less if MANPAGER is set;
+            # environment overrides it.
+            env={**os.environ, "MANPAGER": "cat", "PAGER": "cat"},
+        )
+        if result.returncode != 0:
+            # Possibly topic not found in database but file existed; skip.
+            return None
+        return result.stdout
+    except Exception:
+        return None
+
+# ----------------------------------------------------------------------
+# 4. Main
+# ----------------------------------------------------------------------
+def main():
+    # Collect paths
+    paths = get_manpaths()
+    print(f"Searching in {len(paths)} man directories...", file=sys.stderr)
+    entries = find_man_files(paths)
+    print(f"Found {len(entries)} manual page files.", file=sys.stderr)
+
+    # Remove exact duplicates (same topic + section from different paths)
+    # Keep the first occurrence, but we still use `man` which picks the first.
+    seen = set()
+    unique_entries = []
+    for name, section, filepath in entries:
+        key = (name, section)
+        if key not in seen:
+            seen.add(key)
+            unique_entries.append((name, section))
+    print(f"After deduplication: {len(unique_entries)} unique manuals.", file=sys.stderr)
+
+    dataset = []
+    # We'll write JSON Lines (one object per line) to avoid holding everything in memory.
+    # If you prefer a single JSON array, you can collect all objects first.
+    with open("manuals.jsonl", "w", encoding="utf-8") as fout:
+        for idx, (name, section) in enumerate(unique_entries, 1):
+            text = render_man(name, section)
+            if text is None:
+                # Could not render – skip or log
+                continue
+            record = {
+                "topic": name,
+                "section": section,
+                "manual": text,
+            }
+            # Write as JSON Lines (one per line)
+            fout.write(json.dumps(record, ensure_ascii=False) + "\n")
+
+            if idx % 100 == 0:
+                print(f"Processed {idx}/{len(unique_entries)}...", file=sys.stderr)
+
+    print("Done. Output written to manuals.jsonl", file=sys.stderr)
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1 @@
+pathlib

shell.nix

@@ -0,0 +1,38 @@
+{ pkgs ? import <nixpkgs> {
+    config = {
+      allowUnfree = true;
+      cudaSupport = true;
+    };
+  }
+}:
+
+pkgs.mkShell {
+  name = "LinuxAssistant";
+
+  buildInputs = with pkgs; [
+    # Python + uv
+    python312
+    uv
+
+    # Common native deps useful for ML/CUDA projects
+    stdenv.cc.cc.lib   # libstdc++
+    zlib
+    libGL
+  ];
+
+  shellHook = ''
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo "  uv   version: $(uv --version)"
+    echo "  Python:       $(python --version)"
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+
+    # Create venv with uv if it doesn't exist yet
+    if [ ! -d ".venv" ]; then
+      echo "→ Creating venv with uv..."
+      uv venv .venv --python python3.12
+    fi
+
+    # Activate it
+    source .venv/bin/activate
+  '';
+}