refactor: reorganize CCG into hexagonal architecture

Author: tae2089

README.md

@@ -146,52 +146,55 @@ Actual output from CCG parsing its own codebase.
 
 ```
 $ ccg build .
-Build complete: 127 files, 1220 nodes, 12222 edges
+Build complete: 145 files, 1654 nodes, 10489 edges
 ```
 
 ### 2. Graph Statistics
 
 ```
 $ ccg status
-Nodes: 1220
-Edges: 12222
-Files: 127
+Nodes: 1654
+Edges: 3767
+Files: 192
 
 Node kinds:
-  class:    124
-  file:     127
-  function: 405
-  test:     543
-  type:      21
+  class: 253
+  file: 145
+  function: 1111
+  package: 47
+  type: 98
 
 Edge kinds:
-  calls:        9245
-  contains:     1097
-  imports_from: 1128
-  inherits:        1
-  tested_by:     751
-
-Postprocess:
-  Status: ok
-  Fail-closed: 0
-  Recent failures: 0
+  calls: 1822
+  contains: 1597
+  imports_from: 278
+  implements: 66
+  inherits: 4
+
+Fallback call analysis:
+  calls: 1823
+  fallback_calls: 0
+  fallback_ratio: 0.00%
 ```
 
 ### 3. Code Search
 
 ```
 $ ccg search "impact analysis"
-internal/analysis/impact/impact_test.go  file      internal/analysis/impact/impact_test.go:1
-internal/analysis/impact/impact.go       file      internal/analysis/impact/impact.go:1
-mcp.ImpactAnalyzer                       type      internal/mcp/server.go:36
-impact.EdgeReader                        type      internal/analysis/impact/impact.go:12
-impact.Analyzer.ImpactRadius             function  internal/analysis/impact/impact.go:42
-internal/mcp/handler_analysis.go         file      internal/mcp/handler_analysis.go:1
-
-$ ccg search "dead code"
-deadcode.Options          class     internal/analysis/deadcode/service.go:14
-deadcode.Service.Find     function  internal/analysis/deadcode/service.go:38
-mcp.handlers.findDeadCode function  internal/mcp/handler_analysis.go:273
+internal/app/analyze/impact/impact.go              file      internal/app/analyze/impact/impact.go:1
+mcp.impactRadiusResponse                           class     internal/adapters/inbound/mcp/handler_analysis.go:36
+internal/adapters/inbound/mcp/handler_analysis.go  file      internal/adapters/inbound/mcp/handler_analysis.go:1
+mcp.ImpactAnalyzer                                 type      internal/adapters/inbound/mcp/deps.go:40
+mcp.impactRadiusMetadata                           class     internal/adapters/inbound/mcp/handler_analysis.go:27
+mcp.handlers.getImpactRadius                       function  internal/adapters/inbound/mcp/handler_analysis.go:109
+
+$ ccg search "repository sync"
+reposync.Service.Sync                               function  internal/app/reposync/service.go:27
+remote.buildRepoSyncHTTP                            function  internal/runtime/remote/http.go:88
+reposync.syncPayload                                class     internal/app/reposync/queue.go:94
+reposync.SyncHandlerFunc                            type      internal/app/reposync/queue.go:21
+reposync.SyncQueue                                  class     internal/app/reposync/queue.go:118
+webhook.SyncFunc                                    type      internal/adapters/inbound/webhook/handler.go:22
 ```
 
 ### 4. Agent Integration via MCP
@@ -205,7 +208,7 @@ The agent calls CCG MCP tools and answers directly from the graph:
 ```
 trace_flow(qualified_name: "webhook.WebhookHandler.ServeHTTP")
 → WebhookHandler.ServeHTTP
-  → SyncQueue.Enqueue
+  → SyncQueue.Add
     → safeHandle (retry loop: max 3 attempts, exponential backoff 1s→30s)
       → clone (git clone, 15min timeout)
       → build (ccg build, same context)
@@ -215,7 +218,7 @@ trace_flow(qualified_name: "webhook.WebhookHandler.ServeHTTP")
 
 ```
 search(query: "authentication")
-→ internal/webhook/handler.go  (HMAC signature validation)
+→ internal/adapters/inbound/webhook/handler.go  (HMAC signature validation)
 → cmd/ccg-server/main.go       (--webhook-secret flag)
 ```
 

cmd/ccg-server/main.go

@@ -10,9 +10,10 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 
+	ccgserver "github.com/tae2089/code-context-graph/internal/adapters/inbound/http"
 	ccgconfig "github.com/tae2089/code-context-graph/internal/config"
-	"github.com/tae2089/code-context-graph/internal/core"
-	ccgserver "github.com/tae2089/code-context-graph/internal/server"
+	ccgruntime "github.com/tae2089/code-context-graph/internal/runtime"
+	remote "github.com/tae2089/code-context-graph/internal/runtime/remote"
 	"github.com/tae2089/trace"
 )
 
@@ -25,7 +26,7 @@ var (
 // @intent run the self-hosted HTTP MCP/webhook server as a dedicated binary.
 func main() {
 	logger := slog.Default()
-	rt := core.NewRuntime(logger)
+	rt := ccgruntime.NewRuntime(logger)
 	cmd := newRootCmd(rt, version)
 	if err := cmd.Execute(); err != nil {
 		slog.Error("server command failed", trace.SlogError(err))
@@ -38,7 +39,7 @@ func main() {
 // newRootCmd builds the ccg-server command with HTTP and webhook options.
 // @intent keep self-hosted server flags separate from the local ccg CLI.
 // @sideEffect reads config/env, opens the DB, and starts a long-running HTTP server.
-func newRootCmd(rt *core.Runtime, serviceVersion string) *cobra.Command {
+func newRootCmd(rt *ccgruntime.Runtime, serviceVersion string) *cobra.Command {
 	cfg := ccgserver.DefaultConfig()
 	cfg.Transport = "streamable-http"
 
@@ -107,7 +108,7 @@ func newRootCmd(rt *core.Runtime, serviceVersion string) *cobra.Command {
 			return nil
 		},
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return ccgserver.Run(rt, cfg, serviceVersion, ccgconfig.RagIndexDir(), ccgconfig.RagDescription())
+			return remote.RunHTTP(rt, cfg, serviceVersion, ccgconfig.RagIndexDir(), ccgconfig.RagDescription())
 		},
 	}
 

cmd/ccg/health_test.go

@@ -10,9 +10,9 @@ import (
 	"testing"
 	"time"
 
+	ccgserver "github.com/tae2089/code-context-graph/internal/adapters/inbound/http"
+	"github.com/tae2089/code-context-graph/internal/app/reposync"
 	ccgdb "github.com/tae2089/code-context-graph/internal/db"
-	ccgserver "github.com/tae2089/code-context-graph/internal/server"
-	"github.com/tae2089/code-context-graph/internal/webhook"
 )
 
 func TestHandleHealth_OK(t *testing.T) {
@@ -98,10 +98,10 @@ func TestReadyHandler_MethodNotAllowed(t *testing.T) {
 }
 
 func TestStatusHandler_ReportsWebhookQueueFull(t *testing.T) {
-	q := webhook.NewSyncQueueWithConfig(nil, 0, func(context.Context, string, string, string) error {
+	q := reposync.NewSyncQueueWithConfig(nil, 0, func(context.Context, string, string, string) error {
 		return nil
-	}, webhook.QueueConfig{
-		RetryConfig:     webhook.RetryConfig{MaxAttempts: 1, BaseDelay: time.Millisecond, MaxDelay: time.Millisecond},
+	}, reposync.QueueConfig{
+		RetryConfig:     reposync.RetryConfig{MaxAttempts: 1, BaseDelay: time.Millisecond, MaxDelay: time.Millisecond},
 		MaxTrackedRepos: 1,
 	})
 	defer q.Shutdown()
@@ -112,18 +112,18 @@ func TestStatusHandler_ReportsWebhookQueueFull(t *testing.T) {
 	req := httptest.NewRequest(http.MethodGet, "/status", nil)
 	rec := httptest.NewRecorder()
 
-	ccgserver.StatusHandler(func(r *http.Request) error { return nil }, time.Minute, func() *webhook.SyncQueue { return q }).ServeHTTP(rec, req)
+	ccgserver.StatusHandler(func(r *http.Request) error { return nil }, time.Minute, func() *reposync.SyncQueue { return q }).ServeHTTP(rec, req)
 
 	if rec.Code != http.StatusServiceUnavailable {
 		t.Fatalf("expected 503, got %d body=%s", rec.Code, rec.Body.String())
 	}
 }
 
 func TestStatusHandler_ReportsWebhookQueueAges(t *testing.T) {
-	q := webhook.NewSyncQueueWithConfig(nil, 0, func(context.Context, string, string, string) error {
+	q := reposync.NewSyncQueueWithConfig(nil, 0, func(context.Context, string, string, string) error {
 		return nil
-	}, webhook.QueueConfig{
-		RetryConfig:     webhook.RetryConfig{MaxAttempts: 1, BaseDelay: time.Millisecond, MaxDelay: time.Millisecond},
+	}, reposync.QueueConfig{
+		RetryConfig:     reposync.RetryConfig{MaxAttempts: 1, BaseDelay: time.Millisecond, MaxDelay: time.Millisecond},
 		MaxTrackedRepos: 2,
 	})
 	defer q.Shutdown()
@@ -135,7 +135,7 @@ func TestStatusHandler_ReportsWebhookQueueAges(t *testing.T) {
 	req := httptest.NewRequest(http.MethodGet, "/status", nil)
 	rec := httptest.NewRecorder()
 
-	ccgserver.StatusHandler(func(r *http.Request) error { return nil }, time.Minute, func() *webhook.SyncQueue { return q }).ServeHTTP(rec, req)
+	ccgserver.StatusHandler(func(r *http.Request) error { return nil }, time.Minute, func() *reposync.SyncQueue { return q }).ServeHTTP(rec, req)
 
 	if rec.Code != http.StatusOK {
 		t.Fatalf("expected 200, got %d body=%s", rec.Code, rec.Body.String())
@@ -154,10 +154,10 @@ func TestStatusHandler_ReportsWebhookQueueAges(t *testing.T) {
 }
 
 func TestReadyHandler_ReportsWebhookQueueDelay(t *testing.T) {
-	q := webhook.NewSyncQueueWithConfig(nil, 0, func(context.Context, string, string, string) error {
+	q := reposync.NewSyncQueueWithConfig(nil, 0, func(context.Context, string, string, string) error {
 		return nil
-	}, webhook.QueueConfig{
-		RetryConfig:     webhook.RetryConfig{MaxAttempts: 1, BaseDelay: time.Millisecond, MaxDelay: time.Millisecond},
+	}, reposync.QueueConfig{
+		RetryConfig:     reposync.RetryConfig{MaxAttempts: 1, BaseDelay: time.Millisecond, MaxDelay: time.Millisecond},
 		MaxTrackedRepos: 2,
 	})
 	defer q.Shutdown()
@@ -180,11 +180,11 @@ func TestReadyHandler_ReportsWebhookQueueDelay(t *testing.T) {
 
 func TestStatusHandler_ReportsUnresolvedWebhookFailure(t *testing.T) {
 	done := make(chan struct{})
-	q := webhook.NewSyncQueueWithConfig(nil, 1, func(context.Context, string, string, string) error {
+	q := reposync.NewSyncQueueWithConfig(nil, 1, func(context.Context, string, string, string) error {
 		close(done)
 		return errors.New("boom")
-	}, webhook.QueueConfig{
-		RetryConfig:     webhook.RetryConfig{MaxAttempts: 1, BaseDelay: time.Millisecond, MaxDelay: time.Millisecond},
+	}, reposync.QueueConfig{
+		RetryConfig:     reposync.RetryConfig{MaxAttempts: 1, BaseDelay: time.Millisecond, MaxDelay: time.Millisecond},
 		MaxTrackedRepos: 2,
 	})
 	defer q.Shutdown()
@@ -206,7 +206,7 @@ func TestStatusHandler_ReportsUnresolvedWebhookFailure(t *testing.T) {
 	req := httptest.NewRequest(http.MethodGet, "/status", nil)
 	rec := httptest.NewRecorder()
 
-	ccgserver.StatusHandler(func(r *http.Request) error { return nil }, time.Minute, func() *webhook.SyncQueue { return q }).ServeHTTP(rec, req)
+	ccgserver.StatusHandler(func(r *http.Request) error { return nil }, time.Minute, func() *reposync.SyncQueue { return q }).ServeHTTP(rec, req)
 
 	if rec.Code != http.StatusOK {
 		t.Fatalf("expected 200, got %d body=%s", rec.Code, rec.Body.String())
@@ -224,19 +224,19 @@ func TestWebhookStatsDegraded_PerRepoUnresolvedFailure(t *testing.T) {
 	errTime := time.Now()
 	successTime := errTime.Add(2 * time.Minute)
 
-	if !ccgserver.WebhookStatsDegraded(webhook.SyncQueueStats{
+	if !ccgserver.WebhookStatsDegraded(reposync.SyncQueueStats{
 		LastSuccessTime: successTime,
-		RecentRepos: []webhook.RepoStats{{
+		RecentRepos: []reposync.RepoStats{{
 			Repo:          "org/failrepo",
 			LastErrorTime: errTime,
 		}},
 	}) {
 		t.Fatal("expected unresolved repo failure to degrade status")
 	}
 
-	if ccgserver.WebhookStatsDegraded(webhook.SyncQueueStats{
+	if ccgserver.WebhookStatsDegraded(reposync.SyncQueueStats{
 		LastSuccessTime: successTime,
-		RecentRepos: []webhook.RepoStats{{
+		RecentRepos: []reposync.RepoStats{{
 			Repo:            "org/recovered",
 			LastErrorTime:   errTime,
 			LastSuccessTime: successTime,
@@ -249,16 +249,16 @@ func TestWebhookStatsDegraded_PerRepoUnresolvedFailure(t *testing.T) {
 func TestStatusHandler_DegradedWhenRecentRepoFailureUnresolved(t *testing.T) {
 	var mu sync.Mutex
 	completed := make([]string, 0, 2)
-	q := webhook.NewSyncQueueWithConfig(nil, 1, func(_ context.Context, repoFullName, cloneURL, branch string) error {
+	q := reposync.NewSyncQueueWithConfig(nil, 1, func(_ context.Context, repoFullName, cloneURL, branch string) error {
 		mu.Lock()
 		completed = append(completed, repoFullName)
 		mu.Unlock()
 		if repoFullName == "org/failrepo" {
 			return errors.New("boom")
 		}
 		return nil
-	}, webhook.QueueConfig{
-		RetryConfig:     webhook.RetryConfig{MaxAttempts: 1, BaseDelay: time.Millisecond, MaxDelay: time.Millisecond},
+	}, reposync.QueueConfig{
+		RetryConfig:     reposync.RetryConfig{MaxAttempts: 1, BaseDelay: time.Millisecond, MaxDelay: time.Millisecond},
 		MaxTrackedRepos: 10,
 	})
 	defer q.Shutdown()
@@ -282,7 +282,7 @@ func TestStatusHandler_DegradedWhenRecentRepoFailureUnresolved(t *testing.T) {
 
 	req := httptest.NewRequest(http.MethodGet, "/status", nil)
 	rec := httptest.NewRecorder()
-	ccgserver.StatusHandler(func(r *http.Request) error { return nil }, time.Minute, func() *webhook.SyncQueue { return q }).ServeHTTP(rec, req)
+	ccgserver.StatusHandler(func(r *http.Request) error { return nil }, time.Minute, func() *reposync.SyncQueue { return q }).ServeHTTP(rec, req)
 
 	if rec.Code != http.StatusOK {
 		t.Fatalf("expected 200, got %d body=%s", rec.Code, rec.Body.String())
@@ -298,11 +298,11 @@ func TestStatusHandler_DegradedWhenRecentRepoFailureUnresolved(t *testing.T) {
 
 func TestStatusHandler_DBNotReadyTakesPrecedenceOverWebhookDegraded(t *testing.T) {
 	done := make(chan struct{})
-	q := webhook.NewSyncQueueWithConfig(nil, 1, func(_ context.Context, repoFullName, cloneURL, branch string) error {
+	q := reposync.NewSyncQueueWithConfig(nil, 1, func(_ context.Context, repoFullName, cloneURL, branch string) error {
 		close(done)
 		return errors.New("boom")
-	}, webhook.QueueConfig{
-		RetryConfig:     webhook.RetryConfig{MaxAttempts: 1, BaseDelay: time.Millisecond, MaxDelay: time.Millisecond},
+	}, reposync.QueueConfig{
+		RetryConfig:     reposync.RetryConfig{MaxAttempts: 1, BaseDelay: time.Millisecond, MaxDelay: time.Millisecond},
 		MaxTrackedRepos: 10,
 	})
 	defer q.Shutdown()
@@ -325,7 +325,7 @@ func TestStatusHandler_DBNotReadyTakesPrecedenceOverWebhookDegraded(t *testing.T
 
 	req := httptest.NewRequest(http.MethodGet, "/status", nil)
 	rec := httptest.NewRecorder()
-	ccgserver.StatusHandler(func(r *http.Request) error { return errors.New("db down") }, time.Minute, func() *webhook.SyncQueue { return q }).ServeHTTP(rec, req)
+	ccgserver.StatusHandler(func(r *http.Request) error { return errors.New("db down") }, time.Minute, func() *reposync.SyncQueue { return q }).ServeHTTP(rec, req)
 
 	if rec.Code != http.StatusServiceUnavailable {
 		t.Fatalf("expected 503, got %d body=%s", rec.Code, rec.Body.String())
@@ -340,7 +340,7 @@ func TestStatusHandler_DBNotReadyTakesPrecedenceOverWebhookDegraded(t *testing.T
 }
 
 func TestReadyHandler_IgnoresUnresolvedWebhookFailure(t *testing.T) {
-	stats := webhook.SyncQueueStats{LastErrorTime: time.Now()}
+	stats := reposync.SyncQueueStats{LastErrorTime: time.Now()}
 	req := httptest.NewRequest(http.MethodGet, "/ready", nil)
 	rec := httptest.NewRecorder()
 
@@ -355,11 +355,11 @@ func TestReadyHandler_IgnoresUnresolvedWebhookFailure(t *testing.T) {
 
 func TestStatusHandler_ReportsPerRepoRecentRepos(t *testing.T) {
 	done := make(chan struct{})
-	q := webhook.NewSyncQueueWithConfig(nil, 1, func(_ context.Context, repoFullName, cloneURL, branch string) error {
+	q := reposync.NewSyncQueueWithConfig(nil, 1, func(_ context.Context, repoFullName, cloneURL, branch string) error {
 		close(done)
 		return nil
-	}, webhook.QueueConfig{
-		RetryConfig:     webhook.RetryConfig{MaxAttempts: 1, BaseDelay: time.Millisecond, MaxDelay: time.Millisecond},
+	}, reposync.QueueConfig{
+		RetryConfig:     reposync.RetryConfig{MaxAttempts: 1, BaseDelay: time.Millisecond, MaxDelay: time.Millisecond},
 		MaxTrackedRepos: 10,
 	})
 	defer q.Shutdown()
@@ -385,7 +385,7 @@ func TestStatusHandler_ReportsPerRepoRecentRepos(t *testing.T) {
 
 	req := httptest.NewRequest(http.MethodGet, "/status", nil)
 	rec := httptest.NewRecorder()
-	ccgserver.StatusHandler(func(r *http.Request) error { return nil }, time.Minute, func() *webhook.SyncQueue { return q }).ServeHTTP(rec, req)
+	ccgserver.StatusHandler(func(r *http.Request) error { return nil }, time.Minute, func() *reposync.SyncQueue { return q }).ServeHTTP(rec, req)
 
 	if rec.Code != http.StatusOK {
 		t.Fatalf("expected 200, got %d body=%s", rec.Code, rec.Body.String())
@@ -419,11 +419,11 @@ func TestStatusHandler_ReportsPerRepoRecentRepos(t *testing.T) {
 
 func TestStatusHandler_RecentRepos_FailureHasErrorFields(t *testing.T) {
 	done := make(chan struct{})
-	q := webhook.NewSyncQueueWithConfig(nil, 1, func(_ context.Context, repoFullName, cloneURL, branch string) error {
+	q := reposync.NewSyncQueueWithConfig(nil, 1, func(_ context.Context, repoFullName, cloneURL, branch string) error {
 		close(done)
 		return errors.New("auth failed")
-	}, webhook.QueueConfig{
-		RetryConfig:     webhook.RetryConfig{MaxAttempts: 1, BaseDelay: time.Millisecond, MaxDelay: time.Millisecond},
+	}, reposync.QueueConfig{
+		RetryConfig:     reposync.RetryConfig{MaxAttempts: 1, BaseDelay: time.Millisecond, MaxDelay: time.Millisecond},
 		MaxTrackedRepos: 10,
 	})
 	defer q.Shutdown()
@@ -449,7 +449,7 @@ func TestStatusHandler_RecentRepos_FailureHasErrorFields(t *testing.T) {
 
 	req := httptest.NewRequest(http.MethodGet, "/status", nil)
 	rec := httptest.NewRecorder()
-	ccgserver.StatusHandler(func(r *http.Request) error { return nil }, time.Minute, func() *webhook.SyncQueue { return q }).ServeHTTP(rec, req)
+	ccgserver.StatusHandler(func(r *http.Request) error { return nil }, time.Minute, func() *reposync.SyncQueue { return q }).ServeHTTP(rec, req)
 
 	var body map[string]any
 	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
@@ -471,17 +471,17 @@ func TestStatusHandler_RecentRepos_FailureHasErrorFields(t *testing.T) {
 }
 
 func TestStatusHandler_ExistingAggregateFieldsPreserved(t *testing.T) {
-	q := webhook.NewSyncQueueWithConfig(nil, 0, func(context.Context, string, string, string) error {
+	q := reposync.NewSyncQueueWithConfig(nil, 0, func(context.Context, string, string, string) error {
 		return nil
-	}, webhook.QueueConfig{
-		RetryConfig:     webhook.RetryConfig{MaxAttempts: 1, BaseDelay: time.Millisecond, MaxDelay: time.Millisecond},
+	}, reposync.QueueConfig{
+		RetryConfig:     reposync.RetryConfig{MaxAttempts: 1, BaseDelay: time.Millisecond, MaxDelay: time.Millisecond},
 		MaxTrackedRepos: 5,
 	})
 	defer q.Shutdown()
 
 	req := httptest.NewRequest(http.MethodGet, "/status", nil)
 	rec := httptest.NewRecorder()
-	ccgserver.StatusHandler(func(r *http.Request) error { return nil }, time.Minute, func() *webhook.SyncQueue { return q }).ServeHTTP(rec, req)
+	ccgserver.StatusHandler(func(r *http.Request) error { return nil }, time.Minute, func() *reposync.SyncQueue { return q }).ServeHTTP(rec, req)
 
 	var body map[string]any
 	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {