WeKnora deployment source with the reviewed wiki identity, summary and recovery fixes

cli/internal/iostreams/iostreams.go

@@ -0,0 +1,75 @@
+// Package iostreams wraps stdout/stderr/stdin with TTY detection and color awareness.
+//
+// Tests swap the package-level singleton via SetForTest; production code reads
+// the global IO directly. (Tests must not call SetForTest from t.Parallel(),
+// since the swap is process-global.)
+package iostreams
+
+import (
+	"bytes"
+	"io"
+	"os"
+	"testing"
+
+	"github.com/mattn/go-isatty"
+)
+
+// IOStreams holds standard I/O handles plus environment-derived flags.
+type IOStreams struct {
+	In  io.Reader
+	Out io.Writer
+	Err io.Writer
+
+	stdoutTTY bool
+	stderrTTY bool
+}
+
+// IO is the package-level singleton.
+var IO *IOStreams = newProduction()
+
+func newProduction() *IOStreams {
+	return &IOStreams{
+		In:        os.Stdin,
+		Out:       os.Stdout,
+		Err:       os.Stderr,
+		stdoutTTY: isatty.IsTerminal(os.Stdout.Fd()) || isatty.IsCygwinTerminal(os.Stdout.Fd()),
+		stderrTTY: isatty.IsTerminal(os.Stderr.Fd()) || isatty.IsCygwinTerminal(os.Stderr.Fd()),
+	}
+}
+
+// IsStdoutTTY reports whether stdout is a terminal.
+func (s *IOStreams) IsStdoutTTY() bool { return s.stdoutTTY }
+
+// IsStderrTTY reports whether stderr is a terminal.
+func (s *IOStreams) IsStderrTTY() bool { return s.stderrTTY }
+
+// SetForTest replaces the package singleton with in-memory buffers for the
+// duration of t. Call it once per test. Not safe under t.Parallel().
+func SetForTest(t *testing.T) (out, errBuf *bytes.Buffer) {
+	t.Helper()
+	saved := IO
+	out = &bytes.Buffer{}
+	errBuf = &bytes.Buffer{}
+	IO = &IOStreams{In: bytes.NewReader(nil), Out: out, Err: errBuf}
+	t.Cleanup(func() { IO = saved })
+	return out, errBuf
+}
+
+// SetForTestWithTTY is like SetForTest but reports IsStdoutTTY/IsStderrTTY
+// = true so tests can exercise interactive code paths (confirm prompts,
+// color, fancy renderers). Not safe under t.Parallel().
+func SetForTestWithTTY(t *testing.T) (out, errBuf *bytes.Buffer) {
+	t.Helper()
+	saved := IO
+	out = &bytes.Buffer{}
+	errBuf = &bytes.Buffer{}
+	IO = &IOStreams{
+		In:        bytes.NewReader(nil),
+		Out:       out,
+		Err:       errBuf,
+		stdoutTTY: true,
+		stderrTTY: true,
+	}
+	t.Cleanup(func() { IO = saved })
+	return out, errBuf
+}

cli/internal/iostreams/iostreams_test.go

@@ -0,0 +1,35 @@
+package iostreams
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSetForTest(t *testing.T) {
+	out, errBuf := SetForTest(t)
+	IO.Out.Write([]byte("stdout"))
+	IO.Err.Write([]byte("stderr"))
+	assert.Equal(t, "stdout", out.String())
+	assert.Equal(t, "stderr", errBuf.String())
+}
+
+func TestSetForTest_RestoresSingleton(t *testing.T) {
+	original := IO
+	t.Run("nested", func(t *testing.T) {
+		SetForTest(t)
+		assert.NotSame(t, original, IO)
+	})
+	// After the subtest's t.Cleanup runs, IO must be restored.
+	assert.Same(t, original, IO)
+}
+
+func TestProductionGetters(t *testing.T) {
+	// We can't reliably assert the *value* of these (depends on whether tests
+	// run in a TTY) but we can ensure the methods don't panic and return
+	// consistent values across calls.
+	p := newProduction()
+	a, b := p.IsStdoutTTY(), p.IsStderrTTY()
+	assert.Equal(t, a, p.IsStdoutTTY())
+	assert.Equal(t, b, p.IsStderrTTY())
+}