@awiki/cli 0.0.1-beta.2

package/internal/content/service.go

@@ -0,0 +1,314 @@
+package content
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/agentconnect/awiki-cli/internal/authsdk"
+	appconfig "github.com/agentconnect/awiki-cli/internal/config"
+	"github.com/agentconnect/awiki-cli/internal/identity"
+)
+
+type identityServiceError = identity.ServiceError
+
+type Service struct {
+	config  *appconfig.Resolved
+	manager *identity.Manager
+	remote  *identity.RemoteClient
+}
+
+func NewService(resolved *appconfig.Resolved) (*Service, error) {
+	remote, err := identity.NewRemoteClient(resolved)
+	if err != nil {
+		return nil, err
+	}
+	return &Service{
+		config:  resolved,
+		manager: identity.NewManager(resolved.Paths),
+		remote:  remote,
+	}, nil
+}
+
+func (s *Service) Config() *appconfig.Resolved {
+	return s.config
+}
+
+func (s *Service) CreatePage(ctx context.Context, params CreatePageParams) (*CommandResult, error) {
+	record, auth, err := s.requireAuth(ctx)
+	if err != nil {
+		return nil, err
+	}
+	slug := strings.TrimSpace(params.Slug)
+	title := strings.TrimSpace(params.Title)
+	if slug == "" {
+		return nil, ErrSlugRequired
+	}
+	if title == "" {
+		return nil, ErrTitleRequired
+	}
+	visibility, err := normalizeVisibility(params.Visibility, false)
+	if err != nil {
+		return nil, err
+	}
+	payload := map[string]any{
+		"slug":  slug,
+		"title": title,
+		"body":  params.Body,
+	}
+	if visibility != "" {
+		payload["visibility"] = visibility
+	}
+	var result map[string]any
+	if err := s.remote.AuthenticatedRPCCall(ctx, contentRPCEndpoint, "create", payload, auth, &result); err != nil {
+		return nil, err
+	}
+	return &CommandResult{
+		Data: map[string]any{
+			"action":   "create_page",
+			"identity": identitySummaryFromRecord(record),
+			"page":     result,
+		},
+		Summary: fmt.Sprintf("Created content page %s", slug),
+	}, nil
+}
+
+func (s *Service) ListPages(ctx context.Context) (*CommandResult, error) {
+	record, auth, err := s.requireAuth(ctx)
+	if err != nil {
+		return nil, err
+	}
+	var result map[string]any
+	if err := s.remote.AuthenticatedRPCCall(ctx, contentRPCEndpoint, "list", map[string]any{}, auth, &result); err != nil {
+		return nil, err
+	}
+	count := 0
+	switch typed := result["count"].(type) {
+	case float64:
+		count = int(typed)
+	case int:
+		count = typed
+	}
+	return &CommandResult{
+		Data: map[string]any{
+			"action":   "list_pages",
+			"identity": identitySummaryFromRecord(record),
+			"pages":    result["pages"],
+			"count":    count,
+		},
+		Summary: fmt.Sprintf("Fetched %d content pages", count),
+	}, nil
+}
+
+func (s *Service) GetPage(ctx context.Context, slug string) (*CommandResult, error) {
+	record, auth, err := s.requireAuth(ctx)
+	if err != nil {
+		return nil, err
+	}
+	slug = strings.TrimSpace(slug)
+	if slug == "" {
+		return nil, ErrSlugRequired
+	}
+	var result map[string]any
+	if err := s.remote.AuthenticatedRPCCall(ctx, contentRPCEndpoint, "get", map[string]any{"slug": slug}, auth, &result); err != nil {
+		return nil, err
+	}
+	return &CommandResult{
+		Data: map[string]any{
+			"action":   "get_page",
+			"identity": identitySummaryFromRecord(record),
+			"page":     result,
+		},
+		Summary: fmt.Sprintf("Fetched content page %s", slug),
+	}, nil
+}
+
+func (s *Service) UpdatePage(ctx context.Context, params UpdatePageParams) (*CommandResult, error) {
+	record, auth, err := s.requireAuth(ctx)
+	if err != nil {
+		return nil, err
+	}
+	slug := strings.TrimSpace(params.Slug)
+	if slug == "" {
+		return nil, ErrSlugRequired
+	}
+	payload := map[string]any{"slug": slug}
+	changedFields := make([]string, 0, 3)
+	if title := strings.TrimSpace(params.Title); title != "" {
+		payload["title"] = title
+		changedFields = append(changedFields, "title")
+	}
+	if params.Body != nil {
+		payload["body"] = *params.Body
+		changedFields = append(changedFields, "body")
+	}
+	if params.Visibility != nil {
+		visibility, err := normalizeVisibility(*params.Visibility, true)
+		if err != nil {
+			return nil, err
+		}
+		payload["visibility"] = visibility
+		changedFields = append(changedFields, "visibility")
+	}
+	if len(changedFields) == 0 {
+		return nil, ErrNoUpdateFields
+	}
+	var result map[string]any
+	if err := s.remote.AuthenticatedRPCCall(ctx, contentRPCEndpoint, "update", payload, auth, &result); err != nil {
+		return nil, err
+	}
+	return &CommandResult{
+		Data: map[string]any{
+			"action":         "update_page",
+			"identity":       identitySummaryFromRecord(record),
+			"changed_fields": changedFields,
+			"page":           result,
+		},
+		Summary: fmt.Sprintf("Updated content page %s", slug),
+	}, nil
+}
+
+func (s *Service) RenamePage(ctx context.Context, params RenamePageParams) (*CommandResult, error) {
+	record, auth, err := s.requireAuth(ctx)
+	if err != nil {
+		return nil, err
+	}
+	slug := strings.TrimSpace(params.Slug)
+	target := strings.TrimSpace(params.To)
+	if slug == "" || target == "" {
+		return nil, ErrSlugRequired
+	}
+	var result map[string]any
+	payload := map[string]any{"old_slug": slug, "new_slug": target}
+	if err := s.remote.AuthenticatedRPCCall(ctx, contentRPCEndpoint, "rename", payload, auth, &result); err != nil {
+		return nil, err
+	}
+	return &CommandResult{
+		Data: map[string]any{
+			"action":   "rename_page",
+			"identity": identitySummaryFromRecord(record),
+			"from":     slug,
+			"to":       target,
+			"page":     result,
+		},
+		Summary: fmt.Sprintf("Renamed content page %s to %s", slug, target),
+	}, nil
+}
+
+func (s *Service) DeletePage(ctx context.Context, slug string) (*CommandResult, error) {
+	record, auth, err := s.requireAuth(ctx)
+	if err != nil {
+		return nil, err
+	}
+	slug = strings.TrimSpace(slug)
+	if slug == "" {
+		return nil, ErrSlugRequired
+	}
+	var result map[string]any
+	if err := s.remote.AuthenticatedRPCCall(ctx, contentRPCEndpoint, "delete", map[string]any{"slug": slug}, auth, &result); err != nil {
+		return nil, err
+	}
+	return &CommandResult{
+		Data: map[string]any{
+			"action":   "delete_page",
+			"identity": identitySummaryFromRecord(record),
+			"slug":     slug,
+			"result":   result,
+		},
+		Summary: fmt.Sprintf("Deleted content page %s", slug),
+	}, nil
+}
+
+func (s *Service) requireAuth(ctx context.Context) (*identity.StoredIdentity, *authsdk.Session, error) {
+	record, err := s.requireActiveIdentity()
+	if err != nil {
+		return nil, nil, err
+	}
+	session, err := s.authSession(record)
+	if err != nil {
+		return nil, nil, err
+	}
+	return record, session, nil
+}
+
+func (s *Service) requireActiveIdentity() (*identity.StoredIdentity, error) {
+	if strings.TrimSpace(s.config.ActiveIdentity) == "" {
+		current, err := s.manager.Current()
+		if err != nil {
+			if errors.Is(err, identity.ErrNoDefaultIdentity) {
+				return nil, fmt.Errorf("%w: no active identity is configured", identity.ErrIdentityNotFound)
+			}
+			return nil, err
+		}
+		s.config.ActiveIdentity = current.IdentityName
+	}
+	record, err := s.manager.Load(s.config.ActiveIdentity)
+	if err != nil {
+		return nil, err
+	}
+	return record, nil
+}
+
+func (s *Service) authSession(record *identity.StoredIdentity) (*authsdk.Session, error) {
+	if record == nil {
+		return nil, fmt.Errorf("%w: active identity is required", identity.ErrAuthRequired)
+	}
+	paths, err := s.manager.PathsForIdentity(record.IdentityName)
+	if err != nil {
+		return nil, err
+	}
+	session := authsdk.NewSession(
+		paths.DIDDocumentPath,
+		paths.Key1PrivatePath,
+		record.IdentityName,
+		record.DID,
+		record.JWTToken,
+		func(token string) error { return s.manager.UpdateJWT(record.IdentityName, token) },
+	)
+	session.SetBearer(s.config.UserServiceURL, record.JWTToken)
+	if strings.TrimSpace(record.JWTToken) == "" {
+		ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+		defer cancel()
+		if _, err := session.EnsureJWT(ctx, s.remote.Client(), strings.TrimRight(s.config.UserServiceURL, "/")+didAuthRPCEndpoint); err != nil {
+			var httpErr *authsdk.HTTPError
+			if errors.As(err, &httpErr) {
+				return nil, &identityServiceError{StatusCode: httpErr.StatusCode, Message: httpErr.Message}
+			}
+			var rpcErr *authsdk.RPCError
+			if errors.As(err, &rpcErr) {
+				return nil, &identityServiceError{RPCCode: rpcErr.Code, Message: rpcErr.Message, Data: rpcErr.Data}
+			}
+			return nil, err
+		}
+	}
+	return session, nil
+}
+
+func normalizeVisibility(value string, emptyAllowed bool) (string, error) {
+	visibility := strings.ToLower(strings.TrimSpace(value))
+	if visibility == "" && emptyAllowed {
+		return "", nil
+	}
+	if visibility == "" {
+		return "public", nil
+	}
+	switch visibility {
+	case "public", "draft", "unlisted":
+		return visibility, nil
+	default:
+		return "", ErrVisibilityInvalid
+	}
+}
+
+func identitySummaryFromRecord(record *identity.StoredIdentity) map[string]any {
+	if record == nil {
+		return nil
+	}
+	return map[string]any{
+		"identity_name": record.IdentityName,
+		"did":           record.DID,
+		"handle":        record.Handle,
+	}
+}

package/internal/content/service_test.go

@@ -0,0 +1,165 @@
+package content
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"path/filepath"
+	"testing"
+
+	appconfig "github.com/agentconnect/awiki-cli/internal/config"
+	"github.com/agentconnect/awiki-cli/internal/identity"
+)
+
+func TestCreatePageCallsContentRPC(t *testing.T) {
+	t.Parallel()
+
+	var (
+		gotMethod string
+		gotAuth   string
+		gotParams map[string]any
+	)
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		gotAuth = r.Header.Get("Authorization")
+		if r.URL.Path != contentRPCEndpoint {
+			t.Fatalf("r.URL.Path = %q, want %q", r.URL.Path, contentRPCEndpoint)
+		}
+		var payload map[string]any
+		if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
+			t.Fatalf("Decode() error = %v", err)
+		}
+		gotMethod, _ = payload["method"].(string)
+		gotParams, _ = payload["params"].(map[string]any)
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write([]byte(`{"jsonrpc":"2.0","result":{"slug":"hello-world","title":"Hello","visibility":"draft"},"id":"req-1"}`))
+	}))
+	defer server.Close()
+
+	service := newTestService(t, server.URL, "token-123")
+	result, err := service.CreatePage(context.Background(), CreatePageParams{
+		Slug:       "hello-world",
+		Title:      "Hello",
+		Body:       "# Hello",
+		Visibility: "draft",
+	})
+	if err != nil {
+		t.Fatalf("CreatePage() error = %v", err)
+	}
+	if gotMethod != "create" {
+		t.Fatalf("rpc method = %q, want create", gotMethod)
+	}
+	if gotAuth != "Bearer token-123" {
+		t.Fatalf("Authorization = %q, want Bearer token-123", gotAuth)
+	}
+	if got, _ := gotParams["visibility"].(string); got != "draft" {
+		t.Fatalf("params.visibility = %q, want draft", got)
+	}
+	page, _ := result.Data["page"].(map[string]any)
+	if got, _ := page["slug"].(string); got != "hello-world" {
+		t.Fatalf("page.slug = %q, want hello-world", got)
+	}
+}
+
+func TestUpdatePageRejectsEmptyMutation(t *testing.T) {
+	t.Parallel()
+
+	service := newTestService(t, "https://awiki.test", "token-123")
+	_, err := service.UpdatePage(context.Background(), UpdatePageParams{Slug: "hello-world"})
+	if err != ErrNoUpdateFields {
+		t.Fatalf("UpdatePage() error = %v, want %v", err, ErrNoUpdateFields)
+	}
+}
+
+func TestDeletePageMapsRPCError(t *testing.T) {
+	t.Parallel()
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write([]byte(`{"jsonrpc":"2.0","error":{"code":-32004,"message":"slug already exists"},"id":"req-1"}`))
+	}))
+	defer server.Close()
+
+	service := newTestService(t, server.URL, "token-123")
+	_, err := service.DeletePage(context.Background(), "hello-world")
+	if err == nil {
+		t.Fatal("DeletePage() error = nil, want rpc error")
+	}
+	serviceErr, ok := err.(*ServiceError)
+	if !ok {
+		t.Fatalf("DeletePage() error = %T, want *ServiceError", err)
+	}
+	if serviceErr.RPCCode != -32004 {
+		t.Fatalf("serviceErr.RPCCode = %d, want -32004", serviceErr.RPCCode)
+	}
+}
+
+func TestNormalizeVisibility(t *testing.T) {
+	t.Parallel()
+
+	got, err := normalizeVisibility("", false)
+	if err != nil || got != "public" {
+		t.Fatalf("normalizeVisibility('', false) = (%q, %v), want (public, nil)", got, err)
+	}
+	got, err = normalizeVisibility("UNLISTED", false)
+	if err != nil || got != "unlisted" {
+		t.Fatalf("normalizeVisibility('UNLISTED', false) = (%q, %v), want (unlisted, nil)", got, err)
+	}
+	if _, err := normalizeVisibility("private", false); err != ErrVisibilityInvalid {
+		t.Fatalf("normalizeVisibility('private', false) error = %v, want %v", err, ErrVisibilityInvalid)
+	}
+}
+
+func newTestService(t *testing.T, userServiceURL string, jwtToken string) *Service {
+	t.Helper()
+
+	root := t.TempDir()
+	resolved := &appconfig.Resolved{
+		Paths: appconfig.Paths{
+			IdentityDir:          filepath.Join(root, "identities"),
+			LegacyCredentialsDir: filepath.Join(root, "legacy"),
+			DataDir:              filepath.Join(root, "data"),
+			StateDir:             filepath.Join(root, "state"),
+			DatabaseFile:         filepath.Join(root, "data", "awiki-cli.db"),
+		},
+		UserServiceURL:    userServiceURL,
+		MessageServiceURL: userServiceURL,
+		DIDDomain:         "awiki.ai",
+		ActiveIdentity:    "alice",
+	}
+	manager := identity.NewManager(resolved.Paths)
+	createTestIdentity(t, manager, identity.SaveInput{
+		IdentityName: "alice",
+		DisplayName:  "Alice",
+		Handle:       "alice",
+		JWTToken:     jwtToken,
+	})
+	service, err := NewService(resolved)
+	if err != nil {
+		t.Fatalf("NewService() error = %v", err)
+	}
+	return service
+}
+
+func createTestIdentity(t *testing.T, manager *identity.Manager, input identity.SaveInput) {
+	t.Helper()
+
+	generated, err := identity.GenerateIdentity(identity.GenerateOptions{
+		Hostname:    "awiki.ai",
+		PathPrefix:  []string{"user"},
+		ProofDomain: "awiki.ai",
+	})
+	if err != nil {
+		t.Fatalf("GenerateIdentity() error = %v", err)
+	}
+	input.DID = generated.DID
+	input.UniqueID = generated.UniqueID
+	input.DIDDocument = generated.DIDDocument
+	input.Key1PrivatePEM = generated.Key1PrivatePEM
+	input.Key1PublicPEM = generated.Key1PublicPEM
+	input.E2EESigningPrivatePEM = generated.E2EESigningPrivatePEM
+	input.E2EEAgreementPrivatePEM = generated.E2EEAgreementPrivatePEM
+	if _, err := manager.Save(input); err != nil {
+		t.Fatalf("Save() error = %v", err)
+	}
+}

package/internal/content/types.go

@@ -0,0 +1,44 @@
+package content
+
+import "errors"
+
+const (
+	contentRPCEndpoint = "/content/rpc"
+	didAuthRPCEndpoint = "/user-service/did-auth/rpc"
+)
+
+var (
+	ErrSlugRequired         = errors.New("slug is required")
+	ErrTitleRequired        = errors.New("title is required")
+	ErrBodySourceConflict   = errors.New("use either inline markdown or markdown file, not both")
+	ErrNoUpdateFields       = errors.New("no update fields were provided")
+	ErrVisibilityInvalid    = errors.New("visibility must be one of public, draft, or unlisted")
+	ErrAuthIdentityRequired = errors.New("active identity is required")
+)
+
+type ServiceError = identityServiceError
+
+type CommandResult struct {
+	Data     map[string]any
+	Summary  string
+	Warnings []string
+}
+
+type CreatePageParams struct {
+	Slug       string
+	Title      string
+	Body       string
+	Visibility string
+}
+
+type UpdatePageParams struct {
+	Slug       string
+	Title      string
+	Body       *string
+	Visibility *string
+}
+
+type RenamePageParams struct {
+	Slug string
+	To   string
+}

package/internal/docs/topics.go

@@ -0,0 +1,110 @@
+package docs
+
+import "strings"
+
+type Topic struct {
+	Name       string   `json:"name"`
+	Summary    string   `json:"summary"`
+	References []string `json:"references"`
+}
+
+type Index struct {
+	topics map[string]Topic
+	list   []Topic
+}
+
+func NewIndex() *Index {
+	list := []Topic{
+		{
+			Name:    "overview",
+			Summary: "Project-level implementation overview and roadmap",
+			References: []string{
+				"docs/plan/awiki-v2-implementation-plan.md",
+			},
+		},
+		{
+			Name:    "phase-0",
+			Summary: "Frozen implementation constraints and audit outputs",
+			References: []string{
+				"docs/plan/phase-0/implementation-constraints.md",
+				"docs/plan/phase-0/capability-mapping.md",
+				"docs/plan/phase-0/audit-findings.md",
+				"docs/plan/phase-0/adr-index.md",
+			},
+		},
+		{
+			Name:    "architecture",
+			Summary: "Overall v2 architecture and command model",
+			References: []string{
+				"docs/architecture/awiki-v2-architecture.md",
+				"docs/architecture/awiki-command-v2.md",
+				"docs/architecture/awiki-skill-architecture.md",
+			},
+		},
+		{
+			Name:    "skills",
+			Summary: "Skill topology, manifests, templates, and awiki skill entrypoints",
+			References: []string{
+				"docs/architecture/awiki-skill-architecture.md",
+				"skills/README.md",
+				"skills/manifests/skills.yaml",
+			},
+		},
+		{
+			Name:    "output",
+			Summary: "Output contract, dry-run, schema, and exit code rules",
+			References: []string{
+				"docs/architecture/output-format.md",
+			},
+		},
+		{
+			Name:    "review",
+			Summary: "Secondary review checklist and dependency map for PR review",
+			References: []string{
+				"docs/harness/review-spec.md",
+				"docs/plan/phase-0/implementation-constraints.md",
+				"docs/plan/phase-0/audit-findings.md",
+			},
+		},
+		{
+			Name:    "storage",
+			Summary: "Identity layout and SQLite baseline references",
+			References: []string{
+				"docs/plan/phase-0/implementation-constraints.md",
+				"../awiki-agent-id-message/scripts/credential_layout.py",
+				"../awiki-agent-id-message/scripts/local_store.py",
+				"../awiki-agent-id-message/references/local-store-schema.md",
+			},
+		},
+		{
+			Name:    "runtime",
+			Summary: "Runtime mode, listener, heartbeat, and migration references",
+			References: []string{
+				"docs/architecture/awiki-v2-architecture.md",
+				"../awiki-agent-id-message/scripts/setup_realtime.py",
+				"../awiki-agent-id-message/scripts/ws_listener.py",
+				"../awiki-agent-id-message/references/WEBSOCKET_LISTENER.md",
+			},
+		},
+	}
+	index := &Index{topics: make(map[string]Topic, len(list)), list: list}
+	for _, topic := range list {
+		index.topics[strings.ToLower(topic.Name)] = topic
+	}
+	return index
+}
+
+func (i *Index) All() []Topic {
+	if i == nil {
+		return nil
+	}
+	return append([]Topic(nil), i.list...)
+}
+
+func (i *Index) Lookup(name string) (Topic, bool) {
+	if i == nil {
+		return Topic{}, false
+	}
+	topic, ok := i.topics[strings.ToLower(strings.TrimSpace(name))]
+	return topic, ok
+}