feed-the-machine 1.0.0 → 1.2.0

package/ftm-map/scripts/setup-hooks.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+HOOKS_DIR="$HOME/.claude/git-hooks"
+
+# Create hooks directory
+mkdir -p "$HOOKS_DIR"
+
+# Check if hooksPath is already set
+CURRENT="$(git config --global core.hooksPath 2>/dev/null || echo "")"
+if [ "$CURRENT" = "$HOOKS_DIR" ]; then
+  echo "core.hooksPath already configured: $HOOKS_DIR"
+  exit 0
+fi
+
+if [ -n "$CURRENT" ] && [ "$CURRENT" != "$HOOKS_DIR" ]; then
+  echo "WARNING: core.hooksPath is already set to: $CURRENT"
+  echo "Changing to: $HOOKS_DIR"
+  echo "Previous hooks at $CURRENT will NOT run unless manually chained."
+fi
+
+git config --global core.hooksPath "$HOOKS_DIR"
+echo "Set git core.hooksPath to: $HOOKS_DIR"
+echo ""
+echo "NOTE: This is a GLOBAL git config change affecting all repositories."
+echo "The post-commit hook chains to project-local hooks if they exist."
+echo "To revert: git config --global --unset core.hooksPath"

package/ftm-map/scripts/setup.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+VENV_DIR="$SCRIPT_DIR/.venv"
+
+# Check Python version (3.10+ required)
+PYTHON_BIN=""
+for candidate in python3.12 python3.11 python3.10 python3; do
+  if command -v "$candidate" &>/dev/null; then
+    version_ok=$("$candidate" -c "import sys; print(1 if sys.version_info >= (3, 10) else 0)" 2>/dev/null || echo 0)
+    if [ "$version_ok" = "1" ]; then
+      PYTHON_BIN="$candidate"
+      break
+    fi
+  fi
+done
+
+if [ -z "$PYTHON_BIN" ]; then
+  echo "ERROR: Python 3.10+ is required but not found." >&2
+  echo "Install Python 3.10 or higher and try again." >&2
+  exit 1
+fi
+
+PYTHON_VERSION=$("$PYTHON_BIN" -c "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}')")
+echo "Using Python $PYTHON_VERSION at $("$PYTHON_BIN" -c "import sys; print(sys.executable)")"
+
+# Create venv if it doesn't exist
+if [ ! -d "$VENV_DIR" ]; then
+  echo "Creating virtual environment at $VENV_DIR..."
+  "$PYTHON_BIN" -m venv "$VENV_DIR"
+  echo "Virtual environment created."
+else
+  echo "Virtual environment already exists at $VENV_DIR."
+fi
+
+# Install/upgrade dependencies
+echo "Installing dependencies from requirements.txt..."
+"$VENV_DIR/bin/pip" install -q --upgrade pip
+"$VENV_DIR/bin/pip" install -q -r "$SCRIPT_DIR/requirements.txt"
+echo "Dependencies installed."
+
+# Verify the installation
+echo "Verifying installation..."
+"$VENV_DIR/bin/python3" -c "import sqlite_vec; from tree_sitter_language_pack import get_parser; print('ftm-map dependencies OK')"

package/ftm-map/scripts/test_db.py

@@ -0,0 +1,124 @@
+"""Tests for ftm-map database module."""
+import os
+import sys
+import tempfile
+import unittest
+
+sys.path.insert(0, os.path.dirname(__file__))
+from db import (
+    get_connection, add_symbol, remove_symbols_by_file, add_edge,
+    get_symbol_by_id, get_symbol_by_name, get_transitive_deps,
+    get_reverse_deps, fts_search, get_stats
+)
+
+class TestDatabase(unittest.TestCase):
+    def setUp(self):
+        self.tmpdir = tempfile.mkdtemp()
+        self.conn = get_connection(self.tmpdir)
+
+    def tearDown(self):
+        self.conn.close()
+
+    def test_schema_creation(self):
+        """Tables and indexes should exist after connection."""
+        tables = [r[0] for r in self.conn.execute(
+            "SELECT name FROM sqlite_master WHERE type='table'"
+        ).fetchall()]
+        self.assertIn("symbols", tables)
+        self.assertIn("edges", tables)
+        self.assertIn("symbols_fts", tables)
+
+    def test_wal_mode(self):
+        """WAL mode should be enabled."""
+        mode = self.conn.execute("PRAGMA journal_mode").fetchone()[0]
+        self.assertEqual(mode, "wal")
+
+    def test_add_and_get_symbol(self):
+        """Should insert and retrieve a symbol."""
+        sid = add_symbol(self.conn, "handleAuth", "function", "auth.py", 1, 5, "def handleAuth(request)", "Auth handler", "abc123")
+        self.conn.commit()
+        sym = get_symbol_by_id(self.conn, sid)
+        self.assertIsNotNone(sym)
+        self.assertEqual(sym["name"], "handleAuth")
+        self.assertEqual(sym["kind"], "function")
+
+    def test_remove_symbols_by_file(self):
+        """Should remove all symbols for a file."""
+        add_symbol(self.conn, "foo", "function", "test.py", 1, 3)
+        add_symbol(self.conn, "bar", "function", "test.py", 5, 8)
+        add_symbol(self.conn, "baz", "function", "other.py", 1, 3)
+        self.conn.commit()
+        remove_symbols_by_file(self.conn, "test.py")
+        self.conn.commit()
+        self.assertEqual(len(get_symbol_by_name(self.conn, "foo")), 0)
+        self.assertEqual(len(get_symbol_by_name(self.conn, "baz")), 1)
+
+    def test_edges_and_cascade(self):
+        """Edges should be deleted when source symbol is removed."""
+        s1 = add_symbol(self.conn, "caller", "function", "a.py", 1, 5)
+        s2 = add_symbol(self.conn, "callee", "function", "b.py", 1, 5)
+        add_edge(self.conn, s1, s2, "calls")
+        self.conn.commit()
+        remove_symbols_by_file(self.conn, "a.py")
+        self.conn.commit()
+        edges = self.conn.execute("SELECT * FROM edges").fetchall()
+        self.assertEqual(len(edges), 0)
+
+    def test_transitive_deps(self):
+        """Should return transitive dependency chain."""
+        # A calls B, B calls C
+        a = add_symbol(self.conn, "A", "function", "a.py", 1, 5)
+        b = add_symbol(self.conn, "B", "function", "b.py", 1, 5)
+        c = add_symbol(self.conn, "C", "function", "c.py", 1, 5)
+        add_edge(self.conn, a, b, "calls")
+        add_edge(self.conn, b, c, "calls")
+        self.conn.commit()
+        deps = get_transitive_deps(self.conn, a)
+        dep_names = {d["name"] for d in deps}
+        self.assertIn("B", dep_names)
+        self.assertIn("C", dep_names)
+
+    def test_reverse_deps_blast_radius(self):
+        """Blast radius of C should return B and A."""
+        a = add_symbol(self.conn, "A", "function", "a.py", 1, 5)
+        b = add_symbol(self.conn, "B", "function", "b.py", 1, 5)
+        c = add_symbol(self.conn, "C", "function", "c.py", 1, 5)
+        add_edge(self.conn, a, b, "calls")
+        add_edge(self.conn, b, c, "calls")
+        self.conn.commit()
+        blast = get_reverse_deps(self.conn, c)
+        blast_names = {d["name"] for d in blast}
+        self.assertIn("B", blast_names)
+        self.assertIn("A", blast_names)
+
+    def test_fts_search(self):
+        """FTS5 search should rank handleAuth above getUser for 'handle' query."""
+        add_symbol(self.conn, "handleAuth", "function", "auth.py", 1, 5, "def handleAuth(request)", "Handle authentication")
+        add_symbol(self.conn, "getUser", "function", "auth.py", 7, 10, "def getUser(user_id)", "Get user by ID")
+        self.conn.commit()
+        results = fts_search(self.conn, "handle")
+        self.assertGreater(len(results), 0)
+        self.assertEqual(results[0]["name"], "handleAuth")
+
+    def test_cycle_prevention(self):
+        """Recursive CTE should not loop on cycles."""
+        a = add_symbol(self.conn, "A", "function", "a.py", 1, 5)
+        b = add_symbol(self.conn, "B", "function", "b.py", 1, 5)
+        add_edge(self.conn, a, b, "calls")
+        add_edge(self.conn, b, a, "calls")  # cycle!
+        self.conn.commit()
+        deps = get_transitive_deps(self.conn, a)
+        # Should not hang, and should contain B
+        self.assertTrue(any(d["name"] == "B" for d in deps))
+
+    def test_stats(self):
+        """Stats should return correct counts."""
+        add_symbol(self.conn, "x", "function", "x.py", 1, 3)
+        add_symbol(self.conn, "y", "function", "y.py", 1, 3)
+        self.conn.commit()
+        stats = get_stats(self.conn)
+        self.assertEqual(stats["symbols"], 2)
+        self.assertEqual(stats["files"], 2)
+
+if __name__ == "__main__":
+    unittest.main()

package/ftm-map/scripts/test_parser.py

@@ -0,0 +1,106 @@
+"""Tests for ftm-map parser module."""
+import os
+import sys
+import unittest
+
+sys.path.insert(0, os.path.dirname(__file__))
+
+FIXTURES_DIR = os.path.join(os.path.dirname(__file__), "tests", "fixtures", "sample_project")
+
+class TestParser(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        """Check if tree-sitter-language-pack is available."""
+        try:
+            from parser import parse_file, extract_relationships, detect_language
+            cls.parse_file = staticmethod(parse_file)
+            cls.extract_relationships = staticmethod(extract_relationships)
+            cls.detect_language = staticmethod(detect_language)
+            cls.skip_reason = None
+        except ImportError as e:
+            cls.skip_reason = f"tree-sitter-language-pack not installed: {e}"
+
+    def setUp(self):
+        if self.skip_reason:
+            self.skipTest(self.skip_reason)
+
+    def test_detect_language(self):
+        self.assertEqual(self.detect_language("foo.py"), "python")
+        self.assertEqual(self.detect_language("bar.ts"), "typescript")
+        self.assertEqual(self.detect_language("baz.js"), "javascript")
+        self.assertIsNone(self.detect_language("README.md"))
+
+    def test_parse_python_file(self):
+        """Should extract Python functions."""
+        path = os.path.join(FIXTURES_DIR, "auth.py")
+        if not os.path.exists(path):
+            self.skipTest("Fixture not found")
+        symbols = self.parse_file(path)
+        names = {s.name for s in symbols}
+        self.assertIn("handleAuth", names)
+        self.assertIn("validateToken", names)
+        self.assertIn("getUser", names)
+
+    def test_parse_typescript_file(self):
+        """Should extract TypeScript functions and classes."""
+        path = os.path.join(FIXTURES_DIR, "api.ts")
+        if not os.path.exists(path):
+            self.skipTest("Fixture not found")
+        symbols = self.parse_file(path)
+        names = {s.name for s in symbols}
+        self.assertIn("processRequest", names)
+        self.assertIn("ApiController", names)
+
+    def test_parse_javascript_file(self):
+        """Should extract JavaScript functions."""
+        path = os.path.join(FIXTURES_DIR, "utils.js")
+        if not os.path.exists(path):
+            self.skipTest("Fixture not found")
+        symbols = self.parse_file(path)
+        names = {s.name for s in symbols}
+        self.assertIn("formatDate", names)
+        self.assertIn("parseConfig", names)
+
+    def test_symbol_has_content_hash(self):
+        """Every symbol should have a content hash."""
+        path = os.path.join(FIXTURES_DIR, "auth.py")
+        if not os.path.exists(path):
+            self.skipTest("Fixture not found")
+        symbols = self.parse_file(path)
+        for sym in symbols:
+            self.assertTrue(len(sym.content_hash) > 0, f"{sym.name} missing content_hash")
+
+    def test_symbol_has_line_numbers(self):
+        """Every symbol should have start and end line."""
+        path = os.path.join(FIXTURES_DIR, "auth.py")
+        if not os.path.exists(path):
+            self.skipTest("Fixture not found")
+        symbols = self.parse_file(path)
+        for sym in symbols:
+            self.assertGreater(sym.start_line, 0)
+            self.assertGreaterEqual(sym.end_line, sym.start_line)
+
+    def test_extract_relationships(self):
+        """Should extract call relationships."""
+        path = os.path.join(FIXTURES_DIR, "auth.py")
+        if not os.path.exists(path):
+            self.skipTest("Fixture not found")
+        rels = self.extract_relationships(path)
+        # handleAuth calls validateToken and getUser
+        call_targets = {r.target_name for r in rels if r.kind == "calls"}
+        self.assertIn("validateToken", call_targets)
+        self.assertIn("getUser", call_targets)
+
+    def test_unsupported_file_returns_empty(self):
+        """Unsupported file types should return empty list."""
+        symbols = self.parse_file("/tmp/fake.xyz")
+        self.assertEqual(symbols, [])
+
+    def test_nonexistent_file_returns_empty(self):
+        """Non-existent files should return empty list, not error."""
+        symbols = self.parse_file("/tmp/nonexistent_file_12345.py")
+        self.assertEqual(symbols, [])
+
+if __name__ == "__main__":
+    unittest.main()

package/ftm-map/scripts/test_query.py

@@ -0,0 +1,66 @@
+"""Tests for ftm-map query module."""
+import os
+import sys
+import tempfile
+import unittest
+
+sys.path.insert(0, os.path.dirname(__file__))
+from db import get_connection, add_symbol, add_edge
+from query import blast_radius, dependency_chain, search, symbol_info
+
+class TestQuery(unittest.TestCase):
+    def setUp(self):
+        self.tmpdir = tempfile.mkdtemp()
+        self.conn = get_connection(self.tmpdir)
+        # Build test graph: A -> B -> C, D imports A
+        self.a = add_symbol(self.conn, "handleAuth", "function", "auth.py", 1, 5, "def handleAuth(req)", "Auth handler")
+        self.b = add_symbol(self.conn, "validateToken", "function", "auth.py", 7, 10, "def validateToken(token)")
+        self.c = add_symbol(self.conn, "getUser", "function", "users.py", 1, 5, "def getUser(uid)")
+        self.d = add_symbol(self.conn, "processRequest", "function", "api.ts", 1, 8, "function processRequest(req)")
+        add_edge(self.conn, self.a, self.b, "calls")
+        add_edge(self.conn, self.a, self.c, "calls")
+        add_edge(self.conn, self.d, self.a, "calls")
+        self.conn.commit()
+
+    def tearDown(self):
+        self.conn.close()
+
+    def test_blast_radius(self):
+        """Blast radius of getUser should include handleAuth and processRequest."""
+        result = blast_radius(self.conn, "getUser")
+        names = {r["name"] for r in result["results"]}
+        self.assertIn("handleAuth", names)
+        self.assertIn("processRequest", names)
+        self.assertEqual(result["affected_count"], 2)
+
+    def test_dependency_chain(self):
+        """handleAuth depends on validateToken and getUser."""
+        result = dependency_chain(self.conn, "handleAuth")
+        names = {r["name"] for r in result["results"]}
+        self.assertIn("validateToken", names)
+        self.assertIn("getUser", names)
+
+    def test_search(self):
+        """Search for 'auth' should return handleAuth."""
+        result = search(self.conn, "auth")
+        self.assertGreater(result["result_count"], 0)
+        names = {r["name"] for r in result["results"]}
+        self.assertIn("handleAuth", names)
+
+    def test_symbol_info(self):
+        """Should return full details with callers and callees."""
+        result = symbol_info(self.conn, "handleAuth")
+        self.assertEqual(result["name"], "handleAuth")
+        callee_names = {c["name"] for c in result["callees"]}
+        self.assertIn("validateToken", callee_names)
+        self.assertIn("getUser", callee_names)
+        caller_names = {c["name"] for c in result["callers"]}
+        self.assertIn("processRequest", caller_names)
+
+    def test_missing_symbol(self):
+        """Query for non-existent symbol should return error."""
+        result = blast_radius(self.conn, "nonexistent")
+        self.assertIn("error", result)
+
+if __name__ == "__main__":
+    unittest.main()

package/ftm-map/scripts/tests/fixtures/sample_project/api.ts

@@ -0,0 +1,16 @@
+import { handleAuth } from './auth';
+
+export function processRequest(req: Request): Response {
+    const user = handleAuth(req);
+    return formatResponse(user);
+}
+
+function formatResponse(data: any): Response {
+    return new Response(JSON.stringify(data));
+}
+
+export class ApiController {
+    handle(req: Request) {
+        return processRequest(req);
+    }
+}

package/ftm-map/scripts/tests/fixtures/sample_project/auth.py

@@ -0,0 +1,15 @@
+"""Authentication module for the sample project."""
+
+def handleAuth(request):
+    """Handle authentication requests."""
+    token = validateToken(request.token)
+    user = getUser(token.user_id)
+    return user
+
+def validateToken(token):
+    """Validate a JWT token."""
+    return {"user_id": 42, "valid": True}
+
+def getUser(user_id):
+    """Get user by ID from database."""
+    return {"id": user_id, "name": "Alice"}

package/ftm-map/scripts/tests/fixtures/sample_project/utils.js

@@ -0,0 +1,16 @@
+/**
+ * Utility functions for the sample project.
+ */
+
+function formatDate(date) {
+    return date.toISOString();
+}
+
+function parseConfig(configStr) {
+    return JSON.parse(configStr);
+}
+
+const processData = (data) => {
+    const config = parseConfig(data.config);
+    return { ...data, config, timestamp: formatDate(new Date()) };
+};