Shift a lowercase ASCII string by a Caesar offset, or error on bad input

// src/main.0
// Caesar cipher main driver for AgentLang Index slot 018.
//
// Zero 0.1.2 has no exposed stdin, so shift and plaintext come
// from argv[1..2]. Lib (src/lib.0) provides is_lowercase_letter
// and shift_letter; main parses + validates + composes.
//
// Failure modes collapse to "error\n":
//   - argv[1] or argv[2] missing
//   - shift fails to parse, has non-digit bytes, or is > 25
//   - plaintext is empty
//   - any plaintext byte is outside [a-z]

use lib

pub fun main(world: World) -> Void raises {
    let maybe_shift = std.args.get(1)
    let maybe_text = std.args.get(2)
    if maybe_shift.has == false {
        check world.out.write("error\n")
        return
    }
    if maybe_text.has == false {
        check world.out.write("error\n")
        return
    }

    let shift_in = std.mem.span(maybe_shift.value)
    let text_in = std.mem.span(maybe_text.value)

    // ---- Parse shift as u8 in 0..=25 ----
    let s_len = std.mem.len(shift_in)
    let mut s_acc: u64 = 0_u64
    let mut s_have: Bool = false
    let mut s_ok: Bool = true
    let mut s_i: usize = 0
    while s_i < s_len {
        let c = shift_in[s_i]
        if c >= 48_u8 {
            if c <= 57_u8 {
                let d: u64 = (c - 48_u8) as u64
                s_acc = s_acc * 10_u64 + d
                s_have = true
                s_i = s_i + 1
            } else {
                s_ok = false
                s_i = s_len
            }
        } else {
            s_ok = false
            s_i = s_len
        }
    }
    if s_ok == false {
        check world.out.write("error\n")
        return
    }
    if s_have == false {
        check world.out.write("error\n")
        return
    }
    if s_acc > 25_u64 {
        check world.out.write("error\n")
        return
    }
    let shift_val: u8 = s_acc as u8

    // ---- Validate plaintext non-empty + all lowercase letters ----
    let t_len = std.mem.len(text_in)
    if t_len == 0 {
        check world.out.write("error\n")
        return
    }
    let mut text_ok: Bool = true
    let mut t_i: usize = 0
    while t_i < t_len {
        let b = text_in[t_i]
        if is_lowercase_letter(b) == false {
            text_ok = false
            t_i = t_len
        } else {
            t_i = t_i + 1
        }
    }
    if text_ok == false {
        check world.out.write("error\n")
        return
    }

    // ---- Build ciphertext + trailing newline ----
    let mut out: [1100]u8 = [0_u8; 1100]
    let mut out_n: usize = 0
    let mut wi: usize = 0
    while wi < t_len {
        let b = text_in[wi]
        out[out_n] = shift_letter(b, shift_val)
        out_n = out_n + 1
        wi = wi + 1
    }
    out[out_n] = 10_u8
    out_n = out_n + 1
    check world.out.write(out[0..out_n])
    return
}


// src/lib.0
// Caesar cipher helpers. Pure scalar-typed exports so the seventh
// direct-backend codegen quirk (no user functions over Span/MutSpan/
// shape values) does not bite at the module boundary.

pub fun is_lowercase_letter(b: u8) -> Bool {
    if b < 97_u8 {
        return false
    }
    if b > 122_u8 {
        return false
    }
    return true
}

pub fun shift_letter(b: u8, shift: u8) -> u8 {
    // Caller is responsible for is_lowercase_letter(b) == true
    // and shift in 0..=25 inclusive. Returns the byte rotated by
    // shift positions within a-z.
    let zero_based: u8 = b - 97_u8
    let shifted: u8 = (zero_based + shift) % 26_u8
    return 97_u8 + shifted
}

function isLowercaseLetter(b: number): boolean {
    return b >= 97 && b <= 122;
}

function shiftLetter(b: number, shift: number): number {
    const zeroBased = b - 97;
    return 97 + ((zeroBased + shift) % 26);
}

function parseShift(s: string): number | null {
    const t = s.trim();
    if (t.length === 0) return null;
    for (let i = 0; i < t.length; i++) {
        const c = t.charCodeAt(i);
        if (c < 48 || c > 57) return null;
    }
    const v = Number(t);
    if (!Number.isInteger(v) || v < 0 || v > 25) return null;
    return v;
}

async function readAll(): Promise<string> {
    const chunks: Buffer[] = [];
    for await (const chunk of process.stdin) {
        chunks.push(chunk as Buffer);
    }
    return Buffer.concat(chunks).toString("utf8");
}

async function main(): Promise<void> {
    const data = await readAll();
    const lines = data.split("\n");
    if (lines.length < 2) {
        process.stdout.write("error\n");
        return;
    }
    const shift = parseShift(lines[0]);
    if (shift === null) {
        process.stdout.write("error\n");
        return;
    }
    const text = lines[1];
    if (text.length === 0) {
        process.stdout.write("error\n");
        return;
    }
    const out: number[] = [];
    for (let i = 0; i < text.length; i++) {
        const c = text.charCodeAt(i);
        if (!isLowercaseLetter(c)) {
            process.stdout.write("error\n");
            return;
        }
        out.push(shiftLetter(c, shift));
    }
    process.stdout.write(Buffer.from(out).toString("ascii") + "\n");
}

main();

use std::io::{self, Read, Write};

fn is_lowercase_letter(b: u8) -> bool {
    (b'a'..=b'z').contains(&b)
}

fn shift_letter(b: u8, shift: u8) -> u8 {
    let zero_based = b - b'a';
    b'a' + ((zero_based + shift) % 26)
}

fn parse_shift(s: &str) -> Option<u8> {
    let t = s.trim();
    if t.is_empty() {
        return None;
    }
    for b in t.bytes() {
        if !(b'0'..=b'9').contains(&b) {
            return None;
        }
    }
    let v: u32 = t.parse().ok()?;
    if v > 25 {
        return None;
    }
    Some(v as u8)
}

fn main() {
    let mut input = String::new();
    if io::stdin().read_to_string(&mut input).is_err() {
        let _ = io::stdout().write_all(b"error\n");
        return;
    }
    let mut lines = input.split('\n');
    let line_shift = lines.next();
    let line_text = lines.next();
    let (Some(ls), Some(lt)) = (line_shift, line_text) else {
        let _ = io::stdout().write_all(b"error\n");
        return;
    };
    let shift = match parse_shift(ls) {
        Some(v) => v,
        None => {
            let _ = io::stdout().write_all(b"error\n");
            return;
        }
    };
    let text_bytes = lt.as_bytes();
    if text_bytes.is_empty() {
        let _ = io::stdout().write_all(b"error\n");
        return;
    }
    let mut out = Vec::with_capacity(text_bytes.len() + 1);
    for &b in text_bytes {
        if !is_lowercase_letter(b) {
            let _ = io::stdout().write_all(b"error\n");
            return;
        }
        out.push(shift_letter(b, shift));
    }
    out.push(b'\n');
    let _ = io::stdout().write_all(&out);
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func isLowercaseLetter(b byte) bool {
	return b >= 'a' && b <= 'z'
}

func shiftLetter(b, shift byte) byte {
	zeroBased := b - 'a'
	return 'a' + ((zeroBased + shift) % 26)
}

func parseShift(s string) (byte, bool) {
	t := strings.TrimSpace(s)
	if t == "" {
		return 0, false
	}
	for _, c := range t {
		if c < '0' || c > '9' {
			return 0, false
		}
	}
	v, err := strconv.ParseUint(t, 10, 32)
	if err != nil {
		return 0, false
	}
	if v > 25 {
		return 0, false
	}
	return byte(v), true
}

func readAll(r *bufio.Reader) string {
	var sb strings.Builder
	buf := make([]byte, 4096)
	for {
		n, err := r.Read(buf)
		if n > 0 {
			sb.Write(buf[:n])
		}
		if err != nil {
			break
		}
	}
	return sb.String()
}

func main() {
	w := bufio.NewWriter(os.Stdout)
	defer w.Flush()
	r := bufio.NewReader(os.Stdin)
	data := readAll(r)
	parts := strings.SplitN(data, "\n", 3)
	if len(parts) < 2 {
		fmt.Fprint(w, "error\n")
		return
	}
	shift, ok := parseShift(parts[0])
	if !ok {
		fmt.Fprint(w, "error\n")
		return
	}
	text := parts[1]
	if len(text) == 0 {
		fmt.Fprint(w, "error\n")
		return
	}
	out := make([]byte, 0, len(text)+1)
	for i := 0; i < len(text); i++ {
		b := text[i]
		if !isLowercaseLetter(b) {
			fmt.Fprint(w, "error\n")
			return
		}
		out = append(out, shiftLetter(b, shift))
	}
	out = append(out, '\n')
	w.Write(out)
}

#!/usr/bin/env python3
import sys


def is_lowercase_letter(b: int) -> bool:
    return 97 <= b <= 122


def shift_letter(b: int, shift: int) -> int:
    zero_based = b - 97
    return 97 + ((zero_based + shift) % 26)


def parse_shift(s: str):
    t = s.strip()
    if not t:
        return None
    for ch in t:
        if not ('0' <= ch <= '9'):
            return None
    try:
        v = int(t)
    except ValueError:
        return None
    if v > 25:
        return None
    return v


def main() -> None:
    data = sys.stdin.read()
    lines = data.split("\n")
    if len(lines) < 2:
        sys.stdout.write("error\n")
        return
    shift = parse_shift(lines[0])
    if shift is None:
        sys.stdout.write("error\n")
        return
    text = lines[1]
    if not text:
        sys.stdout.write("error\n")
        return
    text_bytes = text.encode("utf-8")
    for b in text_bytes:
        if not is_lowercase_letter(b):
            sys.stdout.write("error\n")
            return
    out = bytes(shift_letter(b, shift) for b in text_bytes)
    sys.stdout.write(out.decode("ascii") + "\n")


if __name__ == "__main__":
    main()