@awiki/cli 0.0.1-beta.2

package/internal/cli/debug.go

@@ -0,0 +1,104 @@
+package cli
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"strings"
+
+	appconfig "github.com/agentconnect/awiki-cli/internal/config"
+	"github.com/agentconnect/awiki-cli/internal/identity"
+	"github.com/agentconnect/awiki-cli/internal/output"
+	"github.com/agentconnect/awiki-cli/internal/store"
+	"github.com/spf13/cobra"
+)
+
+func (a *App) openStore() (*appconfig.Resolved, *sql.DB, output.Format, error) {
+	resolved, err := a.resolveConfig()
+	if err != nil {
+		return nil, nil, output.FormatJSON, err
+	}
+	format := normalizedFormat(resolved.OutputFormat)
+	db, err := store.Open(resolved.Paths)
+	if err != nil {
+		return resolved, nil, format, err
+	}
+	return resolved, db, format, nil
+}
+
+func (a *App) storeExit(err error, hint string) error {
+	if err == nil {
+		return nil
+	}
+	switch {
+	case errors.Is(err, store.ErrLegacyDatabaseNotFound), errors.Is(err, sql.ErrNoRows):
+		return output.NewExitError("not_found", 5, err.Error(), hint)
+	case errors.Is(err, store.ErrUnsafeSQL), errors.Is(err, store.ErrUnsupportedLegacySchema):
+		return output.NewExitError("invalid_argument", 2, err.Error(), hint)
+	default:
+		return output.NewExitError("internal_error", 1, err.Error(), hint)
+	}
+}
+
+func (a *App) runDebugDBQuery(cmd *cobra.Command, args []string) error {
+	if len(args) != 1 {
+		return output.NewExitError("invalid_argument", 2, "debug db query requires exactly one SQL statement.", "Usage: awiki-cli debug db query \"SELECT * FROM messages LIMIT 5\"")
+	}
+	resolved, db, format, err := a.openStore()
+	if err != nil {
+		return a.storeExit(err, "Run `awiki-cli doctor` to inspect the database path and configuration.")
+	}
+	defer db.Close()
+	if err := store.EnsureSchema(context.Background(), db); err != nil {
+		return a.storeExit(err, "Initialize the local store before querying it.")
+	}
+	rows, err := store.ExecuteSQL(context.Background(), db, args[0])
+	if err != nil {
+		return a.storeExit(err, "Only single-statement safe SQL is allowed. Avoid destructive statements.")
+	}
+	data := map[string]any{
+		"database_file": resolved.Paths.DatabaseFile,
+		"rows":          rows,
+	}
+	return a.renderSuccess(cmd.CommandPath(), format, a.globals.JQ, data, "SQLite query executed", nil, identityMetaFromResolved(resolved))
+}
+
+func (a *App) runDebugDBImportV1(cmd *cobra.Command, args []string) error {
+	pathOverride, _ := cmd.Flags().GetString("path")
+	resolved, db, format, err := a.openStore()
+	if err != nil {
+		return a.storeExit(err, "Run `awiki-cli doctor` to inspect the database path and configuration.")
+	}
+	defer db.Close()
+	if err := store.EnsureSchema(context.Background(), db); err != nil {
+		return a.storeExit(err, "Initialize the local store before importing legacy data.")
+	}
+	paths := resolved.Paths
+	if strings.TrimSpace(pathOverride) != "" {
+		paths.LegacyDataDir = strings.TrimSpace(pathOverride)
+	}
+	manager := identity.NewManager(paths)
+	if a.globals.DryRun {
+		scan, err := store.ScanLegacyDatabase(context.Background(), paths)
+		if err != nil {
+			return a.storeExit(err, "Make sure the legacy database path is correct.")
+		}
+		data := map[string]any{
+			"plan": map[string]any{
+				"action":      "import_v1_sqlite",
+				"source_scan": scan,
+				"target":      resolved.Paths.DatabaseFile,
+			},
+		}
+		return a.renderSuccess(cmd.CommandPath(), format, a.globals.JQ, data, "Dry run: legacy SQLite import planned", nil, identityMetaFromResolved(resolved))
+	}
+	report, err := store.ImportLegacyDatabase(context.Background(), db, paths, manager)
+	if err != nil {
+		return a.storeExit(err, "Make sure the v1 database exists and identities were imported first.")
+	}
+	data := map[string]any{
+		"database_file": resolved.Paths.DatabaseFile,
+		"import_report": report,
+	}
+	return a.renderSuccess(cmd.CommandPath(), format, a.globals.JQ, data, "Legacy SQLite import completed", report.Warnings, identityMetaFromResolved(resolved))
+}

package/internal/cli/group.go

@@ -0,0 +1,263 @@
+package cli
+
+import (
+	"context"
+	"strconv"
+	"strings"
+
+	"github.com/agentconnect/awiki-cli/internal/message"
+	"github.com/spf13/cobra"
+)
+
+func (a *App) runGroupCreate(cmd *cobra.Command, args []string) error {
+	name, _ := cmd.Flags().GetString("name")
+	description, _ := cmd.Flags().GetString("description")
+	discoverability, _ := cmd.Flags().GetString("discoverability")
+	admissionMode, _ := cmd.Flags().GetString("admission-mode")
+	slug, _ := cmd.Flags().GetString("slug")
+	goal, _ := cmd.Flags().GetString("goal")
+	rules, _ := cmd.Flags().GetString("rules")
+	messagePrompt, _ := cmd.Flags().GetString("message-prompt")
+	docURL, _ := cmd.Flags().GetString("doc-url")
+	maxMembers, _ := cmd.Flags().GetString("max-members")
+	attachmentsAllowed := boolFlagPtr(cmd, "attachments-allowed")
+	memberMaxMessages := int64FlagPtr(cmd, "member-max-messages")
+	memberMaxTotalChars := int64FlagPtr(cmd, "member-max-total-chars")
+	service, format, err := a.messageService()
+	if err != nil {
+		return a.messageExit(err, "Run `awiki-cli doctor` to inspect configuration and identity state.")
+	}
+	request := message.GroupCreateRequest{
+		IdentityName:        a.globals.Identity,
+		Name:                name,
+		Description:         description,
+		Discoverability:     discoverability,
+		AdmissionMode:       admissionMode,
+		Slug:                slug,
+		Goal:                goal,
+		Rules:               rules,
+		MessagePrompt:       messagePrompt,
+		DocURL:              docURL,
+		AttachmentsAllowed:  attachmentsAllowed,
+		MaxMembers:          maxMembers,
+		MemberMaxMessages:   memberMaxMessages,
+		MemberMaxTotalChars: memberMaxTotalChars,
+	}
+	if a.globals.DryRun {
+		return a.renderSuccess(cmd.CommandPath(), format, a.globals.JQ, map[string]any{"plan": map[string]any{"action": "group.create", "identity": a.globals.Identity, "runtime_mode": service.Config().RuntimeMode, "request": request}}, "Dry run: group create planned", nil, a.identityMeta())
+	}
+	result, err := service.CreateGroup(context.Background(), request)
+	if err != nil {
+		return a.messageExit(err, "Ensure the active identity is registered and the message service is reachable.")
+	}
+	return a.renderSuccess(cmd.CommandPath(), format, a.globals.JQ, result.Data, result.Summary, result.Warnings, a.identityMeta())
+}
+
+func (a *App) runGroupShow(cmd *cobra.Command, args []string) error {
+	group, _ := cmd.Flags().GetString("group")
+	service, format, err := a.messageService()
+	if err != nil {
+		return a.messageExit(err, "Run `awiki-cli doctor` to inspect configuration and identity state.")
+	}
+	request := message.GroupGetRequest{IdentityName: a.globals.Identity, Group: group}
+	if a.globals.DryRun {
+		return a.renderSuccess(cmd.CommandPath(), format, a.globals.JQ, map[string]any{"plan": map[string]any{"action": "group.show", "identity": a.globals.Identity, "runtime_mode": service.Config().RuntimeMode, "group": group}}, "Dry run: group show planned", nil, a.identityMeta())
+	}
+	result, err := service.GetGroup(context.Background(), request)
+	if err != nil {
+		return a.messageExit(err, "Make sure the group exists and the active identity can access it.")
+	}
+	return a.renderSuccess(cmd.CommandPath(), format, a.globals.JQ, result.Data, result.Summary, result.Warnings, a.identityMeta())
+}
+
+func (a *App) runGroupJoin(cmd *cobra.Command, args []string) error {
+	group, _ := cmd.Flags().GetString("group")
+	reason, _ := cmd.Flags().GetString("reason")
+	service, format, err := a.messageService()
+	if err != nil {
+		return a.messageExit(err, "Run `awiki-cli doctor` to inspect configuration and identity state.")
+	}
+	request := message.GroupJoinRequest{IdentityName: a.globals.Identity, Group: group, ReasonText: reason}
+	if a.globals.DryRun {
+		return a.renderSuccess(cmd.CommandPath(), format, a.globals.JQ, map[string]any{"plan": map[string]any{"action": "group.join", "identity": a.globals.Identity, "runtime_mode": service.Config().RuntimeMode, "request": request}}, "Dry run: group join planned", nil, a.identityMeta())
+	}
+	result, err := service.JoinGroup(context.Background(), request)
+	if err != nil {
+		return a.messageExit(err, "Make sure the group exists and allows open join for the active identity.")
+	}
+	return a.renderSuccess(cmd.CommandPath(), format, a.globals.JQ, result.Data, result.Summary, result.Warnings, a.identityMeta())
+}
+
+func (a *App) runGroupAdd(cmd *cobra.Command, args []string) error {
+	return a.runGroupMemberMutation(cmd, "add", "add")
+}
+
+func (a *App) runGroupKick(cmd *cobra.Command, args []string) error {
+	return a.runGroupMemberMutation(cmd, "kick", "remove")
+}
+
+func (a *App) runGroupMemberMutation(cmd *cobra.Command, publicAction string, memberAction string) error {
+	group, _ := cmd.Flags().GetString("group")
+	member, _ := cmd.Flags().GetString("member")
+	role, _ := cmd.Flags().GetString("role")
+	reason, _ := cmd.Flags().GetString("reason")
+	service, format, err := a.messageService()
+	if err != nil {
+		return a.messageExit(err, "Run `awiki-cli doctor` to inspect configuration and identity state.")
+	}
+	request := message.GroupMemberRequest{IdentityName: a.globals.Identity, Group: group, Member: member, Role: role, ReasonText: reason}
+	if a.globals.DryRun {
+		return a.renderSuccess(cmd.CommandPath(), format, a.globals.JQ, map[string]any{"plan": map[string]any{"action": "group." + publicAction, "identity": a.globals.Identity, "runtime_mode": service.Config().RuntimeMode, "request": request}}, "Dry run: group membership change planned", nil, a.identityMeta())
+	}
+	var result *message.CommandResult
+	if memberAction == "add" {
+		result, err = service.AddGroupMember(context.Background(), request)
+	} else {
+		result, err = service.RemoveGroupMember(context.Background(), request)
+	}
+	if err != nil {
+		return a.messageExit(err, "Make sure the group and member exist and the active identity has the required role.")
+	}
+	switch publicAction {
+	case "add":
+		result.Summary = "Added member to group"
+	case "kick":
+		result.Summary = "Removed member from group"
+	}
+	return a.renderSuccess(cmd.CommandPath(), format, a.globals.JQ, result.Data, result.Summary, result.Warnings, a.identityMeta())
+}
+
+func (a *App) runGroupLeave(cmd *cobra.Command, args []string) error {
+	group, _ := cmd.Flags().GetString("group")
+	service, format, err := a.messageService()
+	if err != nil {
+		return a.messageExit(err, "Run `awiki-cli doctor` to inspect configuration and identity state.")
+	}
+	request := message.GroupLeaveRequest{IdentityName: a.globals.Identity, Group: group}
+	if a.globals.DryRun {
+		return a.renderSuccess(cmd.CommandPath(), format, a.globals.JQ, map[string]any{"plan": map[string]any{"action": "group.leave", "identity": a.globals.Identity, "runtime_mode": service.Config().RuntimeMode, "request": request}}, "Dry run: group leave planned", nil, a.identityMeta())
+	}
+	result, err := service.LeaveGroup(context.Background(), request)
+	if err != nil {
+		return a.messageExit(err, "Make sure the group exists and the active identity is still a member.")
+	}
+	return a.renderSuccess(cmd.CommandPath(), format, a.globals.JQ, result.Data, result.Summary, result.Warnings, a.identityMeta())
+}
+
+func (a *App) runGroupUpdate(cmd *cobra.Command, args []string) error {
+	group, _ := cmd.Flags().GetString("group")
+	name, _ := cmd.Flags().GetString("name")
+	description, _ := cmd.Flags().GetString("description")
+	discoverability, _ := cmd.Flags().GetString("discoverability")
+	admissionMode, _ := cmd.Flags().GetString("admission-mode")
+	slug, _ := cmd.Flags().GetString("slug")
+	goal, _ := cmd.Flags().GetString("goal")
+	rules, _ := cmd.Flags().GetString("rules")
+	messagePrompt, _ := cmd.Flags().GetString("message-prompt")
+	docURL, _ := cmd.Flags().GetString("doc-url")
+	maxMembers, _ := cmd.Flags().GetString("max-members")
+	attachmentsAllowed := boolFlagPtr(cmd, "attachments-allowed")
+	memberMaxMessages := int64FlagPtr(cmd, "member-max-messages")
+	memberMaxTotalChars := int64FlagPtr(cmd, "member-max-total-chars")
+	service, format, err := a.messageService()
+	if err != nil {
+		return a.messageExit(err, "Run `awiki-cli doctor` to inspect configuration and identity state.")
+	}
+	request := message.GroupUpdateRequest{
+		IdentityName:        a.globals.Identity,
+		Group:               group,
+		Name:                name,
+		Description:         description,
+		Discoverability:     discoverability,
+		AdmissionMode:       admissionMode,
+		Slug:                slug,
+		Goal:                goal,
+		Rules:               rules,
+		MessagePrompt:       messagePrompt,
+		DocURL:              docURL,
+		AttachmentsAllowed:  attachmentsAllowed,
+		MaxMembers:          maxMembers,
+		MemberMaxMessages:   memberMaxMessages,
+		MemberMaxTotalChars: memberMaxTotalChars,
+	}
+	if a.globals.DryRun {
+		return a.renderSuccess(cmd.CommandPath(), format, a.globals.JQ, map[string]any{"plan": map[string]any{"action": "group.update", "identity": a.globals.Identity, "runtime_mode": service.Config().RuntimeMode, "request": request}}, "Dry run: group update planned", nil, a.identityMeta())
+	}
+	result, err := service.UpdateGroup(context.Background(), request)
+	if err != nil {
+		return a.messageExit(err, "Make sure the active identity has permission to update the target group.")
+	}
+	return a.renderSuccess(cmd.CommandPath(), format, a.globals.JQ, result.Data, result.Summary, result.Warnings, a.identityMeta())
+}
+
+func (a *App) runGroupMembers(cmd *cobra.Command, args []string) error {
+	group, _ := cmd.Flags().GetString("group")
+	limit, _ := cmd.Flags().GetInt("limit")
+	service, format, err := a.messageService()
+	if err != nil {
+		return a.messageExit(err, "Run `awiki-cli doctor` to inspect configuration and identity state.")
+	}
+	request := message.GroupMembersRequest{IdentityName: a.globals.Identity, Group: group, Limit: limit}
+	if a.globals.DryRun {
+		return a.renderSuccess(cmd.CommandPath(), format, a.globals.JQ, map[string]any{"plan": map[string]any{"action": "group.list_members", "identity": a.globals.Identity, "runtime_mode": service.Config().RuntimeMode, "request": request}}, "Dry run: group members planned", nil, a.identityMeta())
+	}
+	result, err := service.GroupMembers(context.Background(), request)
+	if err != nil {
+		return a.messageExit(err, "Make sure the group exists and the active identity can access its member list.")
+	}
+	return a.renderSuccess(cmd.CommandPath(), format, a.globals.JQ, result.Data, result.Summary, result.Warnings, a.identityMeta())
+}
+
+func (a *App) runGroupMessages(cmd *cobra.Command, args []string) error {
+	group, _ := cmd.Flags().GetString("group")
+	limit, _ := cmd.Flags().GetInt("limit")
+	cursor, _ := cmd.Flags().GetString("cursor")
+	service, format, err := a.messageService()
+	if err != nil {
+		return a.messageExit(err, "Run `awiki-cli doctor` to inspect configuration and identity state.")
+	}
+	request := message.GroupMessagesRequest{IdentityName: a.globals.Identity, Group: group, Limit: limit, Cursor: cursor}
+	if a.globals.DryRun {
+		return a.renderSuccess(cmd.CommandPath(), format, a.globals.JQ, map[string]any{"plan": map[string]any{"action": "group.list_messages", "identity": a.globals.Identity, "runtime_mode": service.Config().RuntimeMode, "request": request}}, "Dry run: group messages planned", nil, a.identityMeta())
+	}
+	result, err := service.GroupMessages(context.Background(), request)
+	if err != nil {
+		return a.messageExit(err, "Make sure the group exists and the active identity can access its messages.")
+	}
+	return a.renderSuccess(cmd.CommandPath(), format, a.globals.JQ, result.Data, result.Summary, result.Warnings, a.identityMeta())
+}
+
+func boolFlagPtr(cmd *cobra.Command, name string) *bool {
+	if !cmd.Flags().Changed(name) {
+		return nil
+	}
+	value, err := cmd.Flags().GetBool(name)
+	if err != nil {
+		return nil
+	}
+	return &value
+}
+
+func int64FlagPtr(cmd *cobra.Command, name string) *int64 {
+	if !cmd.Flags().Changed(name) {
+		return nil
+	}
+	value, err := cmd.Flags().GetInt(name)
+	if err != nil {
+		return nil
+	}
+	result := int64(value)
+	return &result
+}
+
+func parseInt64OrEmpty(value string) *int64 {
+	value = strings.TrimSpace(value)
+	if value == "" {
+		return nil
+	}
+	parsed, err := strconv.ParseInt(value, 10, 64)
+	if err != nil {
+		return nil
+	}
+	return &parsed
+}