loop-task 1.3.0 → 1.4.0

package/dist/cli.js

@@ -5,6 +5,7 @@ import { Logger } from "./logger.js";
 import { runLoop } from "./core/foreground-loop.js";
 import { buildLoopOptions } from "./loop-config.js";
 import { startLoop } from "./client/commands.js";
+import { listProjectsCli, createProjectCli, renameProjectCli, setProjectColorCli, deleteProjectCli, resolveProjectId, } from "./client/commands.js";
 import { t } from "./i18n/index.js";
 const require = createRequire(import.meta.url);
 const packageJson = require("../package.json");
@@ -30,12 +31,26 @@ program
     .option("--max-runs <n>", t("cli.optMaxRuns"), parseInt)
     .option("--verbose", t("cli.optVerbose"), false)
     .option("--cwd <dir>", t("cli.optCwd"))
+    .option("--project <name>", t("cli.optProject"))
     .action(async (intervalStr, cmdArgs, opts) => {
-    const built = buildLoopOptions(intervalStr, cmdArgs[0], cmdArgs.slice(1), {
-        ...opts,
-        cwd: opts.cwd ?? process.cwd(),
-    });
-    await startLoop(built.options, built.intervalHuman);
+    try {
+        const projectId = opts.project
+            ? await resolveProjectId(opts.project)
+            : undefined;
+        const built = buildLoopOptions(intervalStr, {
+            ...opts,
+            command: cmdArgs[0],
+            commandArgs: cmdArgs.slice(1),
+            cwd: opts.cwd ?? process.cwd(),
+            projectId,
+        });
+        await startLoop(built.options, built.intervalHuman);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(t("cli.error", { message }));
+        process.exit(1);
+    }
 });
 program
     .command("run")
@@ -52,8 +67,10 @@ program
         return;
     }
     const logger = new Logger(opts.verbose ?? false);
-    const built = buildLoopOptions(intervalStr, cmdArgs[0], cmdArgs.slice(1), {
+    const built = buildLoopOptions(intervalStr, {
         ...opts,
+        command: cmdArgs[0],
+        commandArgs: cmdArgs.slice(1),
         cwd: opts.cwd ?? process.cwd(),
     });
     const controller = new AbortController();
@@ -62,6 +79,44 @@ program
     await runLoop(built.options, logger, controller.signal);
     process.exit(0);
 });
+const projectCmd = program.command("project").description(t("cli.projectDescription"));
+projectCmd
+    .command("list")
+    .description(t("cli.projectListDescription"))
+    .action(async () => {
+    await listProjectsCli();
+});
+projectCmd
+    .command("new")
+    .description(t("cli.projectNewDescription"))
+    .argument("<name>", t("cli.projectArgName"))
+    .option("--color <color>", t("cli.optProjectColor"))
+    .action(async (name, opts) => {
+    await createProjectCli(name, opts.color);
+});
+projectCmd
+    .command("rename")
+    .description(t("cli.projectRenameDescription"))
+    .argument("<id-or-name>", t("cli.projectArgIdOrName"))
+    .argument("<new-name>", t("cli.projectArgNewName"))
+    .action(async (idOrName, newName) => {
+    await renameProjectCli(idOrName, newName);
+});
+projectCmd
+    .command("color")
+    .description(t("cli.projectColorDescription"))
+    .argument("<id-or-name>", t("cli.projectArgIdOrName"))
+    .argument("<color>", t("cli.projectArgColor"))
+    .action(async (idOrName, color) => {
+    await setProjectColorCli(idOrName, color);
+});
+projectCmd
+    .command("delete")
+    .description(t("cli.projectDeleteDescription"))
+    .argument("<id-or-name>", t("cli.projectArgIdOrName"))
+    .action(async (idOrName) => {
+    await deleteProjectCli(idOrName);
+});
 program.action(async () => {
     if (!process.execPath.includes("bun")) {
         const { spawn } = await import("node:child_process");

package/dist/client/commands.js

@@ -1,4 +1,5 @@
 import { formatDuration } from "../duration.js";
+import { PROJECT_COLORS } from "../config/constants.js";
 import { t } from "../i18n/index.js";
 import { sendRequest, streamRequest } from "./ipc.js";
 export async function createBackgroundLoop(options, intervalHuman) {
@@ -19,7 +20,7 @@ export async function startLoop(options, intervalHuman) {
     });
     console.log(t("cli.startedTitle"));
     console.log(t("cli.startedId", { id }));
-    console.log(t("cli.startedCommand", { command: `${options.command} ${options.commandArgs.join(" ")}` }));
+    console.log(t("cli.startedCommand", { command: options.command }));
     console.log(t("cli.startedInterval", { interval: intervalHuman }));
     console.log(t("cli.startedStatus"));
     console.log();
@@ -159,3 +160,158 @@ function formatCmd(command, args) {
 function pad(str, width) {
     return str.length >= width ? str + " " : str + " ".repeat(width - str.length);
 }
+async function fetchProjects() {
+    const response = await sendRequest({ type: "project-list" });
+    if (response.type !== "ok") {
+        throw new Error(response.message);
+    }
+    return response.data;
+}
+export function resolveColor(input) {
+    if (PROJECT_COLORS[input])
+        return PROJECT_COLORS[input];
+    if (/^#[0-9a-fA-F]{6}$/.test(input))
+        return input;
+    throw new Error(t("cli.projectInvalidColor", {
+        color: input,
+        valid: Object.keys(PROJECT_COLORS).join(", "),
+    }));
+}
+export async function resolveProjectId(idOrName) {
+    const projects = await fetchProjects();
+    const byId = projects.find((p) => p.id === idOrName);
+    if (byId)
+        return byId.id;
+    const matches = projects.filter((p) => p.name.toLowerCase() === idOrName.toLowerCase());
+    if (matches.length === 1)
+        return matches[0].id;
+    if (matches.length === 0)
+        throw new Error(t("cli.projectNotFound", { name: idOrName }));
+    throw new Error(t("cli.projectAmbiguous", { name: idOrName }));
+}
+export async function listProjectsCli() {
+    try {
+        const projects = await fetchProjects();
+        if (projects.length === 0) {
+            console.log(t("cli.noProjects"));
+            process.exit(0);
+        }
+        const loopResponse = await sendRequest({ type: "list" });
+        const loops = loopResponse.type === "ok" ? loopResponse.data : [];
+        const counts = new Map();
+        for (const loop of loops) {
+            counts.set(loop.projectId, (counts.get(loop.projectId) ?? 0) + 1);
+        }
+        const nameW = Math.max(t("cli.projectHeaderName").length, ...projects.map((p) => p.name.length)) + 2;
+        const idW = Math.max(t("cli.projectHeaderId").length, ...projects.map((p) => p.id.length)) + 2;
+        const colorW = Math.max(t("cli.projectHeaderColor").length, ...projects.map((p) => p.color.length)) + 2;
+        const loopsW = t("cli.projectHeaderLoops").length + 2;
+        const header = pad(t("cli.projectHeaderName"), nameW) +
+            pad(t("cli.projectHeaderId"), idW) +
+            pad(t("cli.projectHeaderColor"), colorW) +
+            pad(t("cli.projectHeaderLoops"), loopsW) +
+            t("cli.projectHeaderSystem");
+        console.log(header);
+        console.log("-".repeat(header.length));
+        for (const project of projects) {
+            console.log(pad(project.name, nameW) +
+                pad(project.id, idW) +
+                pad(project.color, colorW) +
+                pad(String(counts.get(project.id) ?? 0), loopsW) +
+                (project.isSystem ? "yes" : ""));
+        }
+        process.exit(0);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(t("cli.error", { message }));
+        process.exit(1);
+    }
+}
+export async function createProjectCli(name, colorInput) {
+    try {
+        const color = colorInput ? resolveColor(colorInput) : PROJECT_COLORS.cyan;
+        const response = await sendRequest({
+            type: "project-create",
+            payload: { name, color },
+        });
+        if (response.type !== "ok") {
+            throw new Error(response.message);
+        }
+        const id = response.data.id;
+        console.log(t("cli.projectCreated", { name, id }));
+        process.exit(0);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(t("cli.error", { message }));
+        process.exit(1);
+    }
+}
+export async function renameProjectCli(idOrName, newName) {
+    try {
+        const id = await resolveProjectId(idOrName);
+        const response = await sendRequest({
+            type: "project-update",
+            payload: { id, name: newName },
+        });
+        if (response.type !== "ok") {
+            throw new Error(response.message);
+        }
+        console.log(t("cli.projectRenamed", { name: newName }));
+        process.exit(0);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(t("cli.error", { message }));
+        process.exit(1);
+    }
+}
+export async function setProjectColorCli(idOrName, colorInput) {
+    try {
+        const projects = await fetchProjects();
+        const byId = projects.find((p) => p.id === idOrName);
+        const matches = byId
+            ? [byId]
+            : projects.filter((p) => p.name.toLowerCase() === idOrName.toLowerCase());
+        if (matches.length === 0)
+            throw new Error(t("cli.projectNotFound", { name: idOrName }));
+        if (matches.length > 1)
+            throw new Error(t("cli.projectAmbiguous", { name: idOrName }));
+        const project = matches[0];
+        const color = resolveColor(colorInput);
+        const response = await sendRequest({
+            type: "project-update",
+            payload: { id: project.id, name: project.name, color },
+        });
+        if (response.type !== "ok") {
+            throw new Error(response.message);
+        }
+        console.log(t("cli.projectColorSet", { name: project.name, color }));
+        process.exit(0);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(t("cli.error", { message }));
+        process.exit(1);
+    }
+}
+export async function deleteProjectCli(idOrName) {
+    try {
+        const id = await resolveProjectId(idOrName);
+        const response = await sendRequest({
+            type: "project-delete",
+            payload: { id },
+        });
+        if (response.type !== "ok") {
+            throw new Error(response.message);
+        }
+        console.log(t("cli.projectDeleted", { name: idOrName }));
+        process.exit(0);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(t("cli.error", { message }));
+        process.exit(1);
+    }
+}

package/dist/config/constants.js

@@ -12,3 +12,18 @@ export const LOG_TAIL_DEFAULT = 50;
 export const BOARD_BREAKPOINT_WIDTH = 80;
 export const HEADER_COMPACT_WIDTH = 60;
 export const HOVER_BG = "#1e3a5f";
+export const PROJECT_COLORS = {
+    white: "#ffffff",
+    cyan: "#06b6d4",
+    green: "#4ade80",
+    yellow: "#facc15",
+    orange: "#fb923c",
+    pink: "#f472b6",
+};
+export const PROJECT_COLOR_KEYS = Object.keys(PROJECT_COLORS);
+// Entity theme colors — used for header action buttons and view accents
+export const ENTITY_COLORS = {
+    loop: "#38bdf8", // cyan/blue
+    task: "#a78bfa", // purple
+    project: "#34d399", // green
+};

package/dist/config/paths.js

@@ -9,12 +9,18 @@ export function getDataDir() {
 export function getLoopsDir() {
     return path.join(getDataDir(), "loops");
 }
+export function getTasksDir() {
+    return path.join(getDataDir(), "tasks");
+}
 export function getLogsDir() {
     return path.join(getDataDir(), "logs");
 }
 export function loopFile(id) {
     return path.join(getLoopsDir(), `${id}.json`);
 }
+export function taskFile(id) {
+    return path.join(getTasksDir(), `${id}.json`);
+}
 export function logFile(id) {
     return path.join(getLogsDir(), `${id}.log`);
 }

package/dist/core/command-runner.js

@@ -23,6 +23,7 @@ export async function executeCommand(command, commandArgs, cwd, logStream, signa
         stdin: "ignore",
         cwd: cwd || undefined,
         cancelSignal: signal,
+        shell: true,
     });
     child.stdout.on("data", (chunk) => {
         logStream.write(chunk);
@@ -59,6 +60,7 @@ export async function executeCommandForeground(command, commandArgs, logger, cwd
             stderr: "inherit",
             stdin: "inherit",
             cwd: cwd || undefined,
+            shell: true,
         });
         const endedAt = new Date();
         return {

package/dist/core/foreground-loop.js

@@ -14,6 +14,9 @@ export async function runLoop(options, logger, signal) {
     };
     process.on("SIGINT", onSignal);
     process.on("SIGTERM", onSignal);
+    const command = options.command;
+    const commandArgs = options.commandArgs;
+    const cwd = options.cwd;
     try {
         let isFirstRun = true;
         while (!state.shuttingDown) {
@@ -40,7 +43,7 @@ export async function runLoop(options, logger, signal) {
                 run: state.runCount,
                 maxRuns: options.maxRuns !== null ? `/${options.maxRuns}` : "",
             }));
-            const result = await executeCommandForeground(options.command, options.commandArgs, logger, options.cwd);
+            const result = await executeCommandForeground(command, commandArgs, logger, cwd);
             state.running = false;
             if (result.exitCode !== 0) {
                 logger.error(t("loop.commandFailed", { code: result.exitCode }));