204 lines
6.2 KiB
Go
204 lines
6.2 KiB
Go
package main
|
||
|
||
import (
|
||
"bufio"
|
||
"context"
|
||
"encoding/json"
|
||
"fmt"
|
||
"os"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/steveyegge/beads/internal/storage"
|
||
"github.com/steveyegge/beads/internal/types"
|
||
"github.com/steveyegge/beads/internal/utils"
|
||
)
|
||
|
||
// ImportOptions configures import behavior.
|
||
type ImportOptions struct {
|
||
DryRun bool
|
||
SkipUpdate bool
|
||
Strict bool
|
||
RenameOnImport bool
|
||
ClearDuplicateExternalRefs bool
|
||
OrphanHandling string
|
||
DeletionIDs []string
|
||
SkipPrefixValidation bool
|
||
ProtectLocalExportIDs map[string]time.Time
|
||
}
|
||
|
||
// ImportResult describes what an import operation did.
|
||
type ImportResult struct {
|
||
Created int
|
||
Updated int
|
||
Unchanged int
|
||
Skipped int
|
||
Deleted int
|
||
Collisions int
|
||
IDMapping map[string]string
|
||
CollisionIDs []string
|
||
PrefixMismatch bool
|
||
ExpectedPrefix string
|
||
MismatchPrefixes map[string]int
|
||
SkippedDependencies []string
|
||
}
|
||
|
||
// importIssuesCore imports issues into the Dolt store.
|
||
// This is a bridge function that delegates to the Dolt store's batch creation.
|
||
func importIssuesCore(ctx context.Context, _ string, store storage.DoltStorage, issues []*types.Issue, opts ImportOptions) (*ImportResult, error) {
|
||
if opts.DryRun || len(issues) == 0 {
|
||
return &ImportResult{Skipped: len(issues)}, nil
|
||
}
|
||
|
||
err := store.CreateIssuesWithFullOptions(ctx, issues, getActorWithGit(), storage.BatchCreateOptions{
|
||
OrphanHandling: storage.OrphanAllow,
|
||
SkipPrefixValidation: opts.SkipPrefixValidation,
|
||
})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return &ImportResult{Created: len(issues)}, nil
|
||
}
|
||
|
||
// importLocalResult holds counts from a local JSONL import.
|
||
type importLocalResult struct {
|
||
Issues int
|
||
Memories int
|
||
}
|
||
|
||
// memoryRecord represents a memory entry in the JSONL export.
|
||
type memoryRecord struct {
|
||
Type string `json:"_type"`
|
||
Key string `json:"key"`
|
||
Value string `json:"value"`
|
||
}
|
||
|
||
// importFromLocalJSONL imports issues (and memories) from a local JSONL file on disk
|
||
// into the Dolt store. Returns the number of issues imported and any error.
|
||
// This is a convenience wrapper around importFromLocalJSONLFull.
|
||
func importFromLocalJSONL(ctx context.Context, store storage.DoltStorage, localPath string) (int, error) {
|
||
result, err := importFromLocalJSONLFull(ctx, store, localPath)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
return result.Issues, nil
|
||
}
|
||
|
||
// parseJSONLFile reads a JSONL file and returns parsed issues and config
|
||
// entries (memories). Pure function — no store I/O.
|
||
func parseJSONLFile(path string) ([]*types.Issue, map[string]string, error) {
|
||
//nolint:gosec // G304: path from user-provided CLI argument
|
||
data, err := os.ReadFile(path)
|
||
if err != nil {
|
||
return nil, nil, fmt.Errorf("failed to read JSONL file %s: %w", path, err)
|
||
}
|
||
|
||
scanner := bufio.NewScanner(strings.NewReader(string(data)))
|
||
// Allow up to 64MB per line for large descriptions
|
||
scanner.Buffer(make([]byte, 0, 1024*1024), 64*1024*1024)
|
||
var issues []*types.Issue
|
||
configEntries := make(map[string]string)
|
||
|
||
for scanner.Scan() {
|
||
line := scanner.Text()
|
||
if line == "" {
|
||
continue
|
||
}
|
||
|
||
// Peek at the record to check for _type field
|
||
var peek map[string]json.RawMessage
|
||
if err := json.Unmarshal([]byte(line), &peek); err != nil {
|
||
return nil, nil, fmt.Errorf("failed to parse JSONL line: %w", err)
|
||
}
|
||
|
||
// Check if this is a memory record
|
||
if rawType, ok := peek["_type"]; ok {
|
||
var typeStr string
|
||
if err := json.Unmarshal(rawType, &typeStr); err == nil && typeStr == "memory" {
|
||
var mem memoryRecord
|
||
if err := json.Unmarshal([]byte(line), &mem); err != nil {
|
||
return nil, nil, fmt.Errorf("failed to parse memory record: %w", err)
|
||
}
|
||
if mem.Key != "" && mem.Value != "" {
|
||
configEntries[kvPrefix+memoryPrefix+mem.Key] = mem.Value
|
||
}
|
||
continue
|
||
}
|
||
}
|
||
|
||
// Regular issue record
|
||
var issue types.Issue
|
||
if err := json.Unmarshal([]byte(line), &issue); err != nil {
|
||
return nil, nil, fmt.Errorf("failed to parse issue from JSONL: %w", err)
|
||
}
|
||
// Skip tombstone entries: these are deleted issues exported by older
|
||
// versions (pre-v0.50) with status "tombstone" and deleted_at set.
|
||
// They are not valid for re-import since "tombstone" is not a real status.
|
||
if issue.Status == "tombstone" {
|
||
continue
|
||
}
|
||
|
||
// v0.35–v0.37 exported "wisp" (bool), renamed to "ephemeral" in v0.38+.
|
||
// map old field name so the flag is preserved on import.
|
||
if _, hasWisp := peek["wisp"]; hasWisp && !issue.Ephemeral {
|
||
var wisp bool
|
||
if err := json.Unmarshal(peek["wisp"], &wisp); err == nil && wisp {
|
||
issue.Ephemeral = true
|
||
}
|
||
}
|
||
|
||
issue.SetDefaults()
|
||
issues = append(issues, &issue)
|
||
}
|
||
if err := scanner.Err(); err != nil {
|
||
return nil, nil, fmt.Errorf("failed to scan JSONL: %w", err)
|
||
}
|
||
|
||
return issues, configEntries, nil
|
||
}
|
||
|
||
// importFromLocalJSONLFull imports issues and memories from a local JSONL file.
|
||
// It detects memory records (lines with "_type":"memory") and imports them
|
||
// via SetConfig, while routing regular issue records through the normal path.
|
||
func importFromLocalJSONLFull(ctx context.Context, store storage.DoltStorage, localPath string) (*importLocalResult, error) {
|
||
issues, configEntries, err := parseJSONLFile(localPath)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
result := &importLocalResult{}
|
||
|
||
// Import memories
|
||
for key, value := range configEntries {
|
||
if err := store.SetConfig(ctx, key, value); err != nil {
|
||
return nil, fmt.Errorf("failed to import config %q: %w", key, err)
|
||
}
|
||
result.Memories++
|
||
}
|
||
|
||
// Import issues
|
||
if len(issues) > 0 {
|
||
// Auto-detect prefix from first issue if not already configured
|
||
configuredPrefix, err := store.GetConfig(ctx, "issue_prefix")
|
||
if err == nil && strings.TrimSpace(configuredPrefix) == "" {
|
||
firstPrefix := utils.ExtractIssuePrefix(issues[0].ID)
|
||
if firstPrefix != "" {
|
||
if err := store.SetConfig(ctx, "issue_prefix", firstPrefix); err != nil {
|
||
return nil, fmt.Errorf("failed to set issue_prefix from imported issues: %w", err)
|
||
}
|
||
}
|
||
}
|
||
|
||
opts := ImportOptions{
|
||
SkipPrefixValidation: true,
|
||
}
|
||
_, err = importIssuesCore(ctx, "", store, issues, opts)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
result.Issues = len(issues)
|
||
}
|
||
|
||
return result, nil
|
||
}
|